| Offset 1, 22 lines modified | Offset 1, 22 lines modified | ||
| 1 | There·is·no·zipfile·comment. | 1 | There·is·no·zipfile·comment. |
| 2 | End-of-central-directory·record: | 2 | End-of-central-directory·record: |
| 3 | ------------------------------- | 3 | ------------------------------- |
| 4 | ··Zip·archive·file·size:···················1 | 4 | ··Zip·archive·file·size:···················1422880·(000000000015B620h) |
| 5 | ··Actual·end-cent-dir·record·offset:·······1 | 5 | ··Actual·end-cent-dir·record·offset:·······1422858·(000000000015B60Ah) |
| 6 | ··Expected·end-cent-dir·record·offset:·····1 | 6 | ··Expected·end-cent-dir·record·offset:·····1422858·(000000000015B60Ah) |
| 7 | ··(based·on·the·length·of·the·central·directory·and·its·expected·offset) | 7 | ··(based·on·the·length·of·the·central·directory·and·its·expected·offset) |
| 8 | ··This·zipfile·constitutes·the·sole·disk·of·a·single-part·archive;·its | 8 | ··This·zipfile·constitutes·the·sole·disk·of·a·single-part·archive;·its |
| 9 | ··central·directory·contains·1 | 9 | ··central·directory·contains·1408·entries. |
| 10 | ··The·central·directory·is·1 | 10 | ··The·central·directory·is·172393·(000000000002A169h)·bytes·long, |
| 11 | ··and·its·(expected)·offset·in·bytes·from·the·beginning·of·the·zipfile | 11 | ··and·its·(expected)·offset·in·bytes·from·the·beginning·of·the·zipfile |
| 12 | ··is·1 | 12 | ··is·1250465·(00000000001314A1h). |
| 13 | Central·directory·entry·#1: | 13 | Central·directory·entry·#1: |
| 14 | --------------------------- | 14 | --------------------------- |
| 15 | ··Assembly-CSharp/ | 15 | ··Assembly-CSharp/ |
| Offset 25, 29 lines modified | Offset 25, 29 lines modified | ||
| 25 | ··file·system·or·operating·system·of·origin:······MS-DOS,·OS/2·or·NT·FAT | 25 | ··file·system·or·operating·system·of·origin:······MS-DOS,·OS/2·or·NT·FAT |
| 26 | ··version·of·encoding·software:···················3.1 | 26 | ··version·of·encoding·software:···················3.1 |
| 27 | ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT | 27 | ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT |
| 28 | ··minimum·software·version·required·to·extract:···1.0 | 28 | ··minimum·software·version·required·to·extract:···1.0 |
| 29 | ··compression·method:·····························none·(stored) | 29 | ··compression·method:·····························none·(stored) |
| 30 | ··file·security·status:···························not·encrypted | 30 | ··file·security·status:···························not·encrypted |
| 31 | ··extended·local·header:··························no | 31 | ··extended·local·header:··························no |
| 32 | ··file·last·modified·on·(DOS·date/time):··········2024·Sep· | 32 | ··file·last·modified·on·(DOS·date/time):··········2024·Sep·4·22:20:28 |
| 33 | ··32-bit·CRC·value·(hex):·························00000000 | 33 | ··32-bit·CRC·value·(hex):·························00000000 |
| 34 | ··compressed·size:································0·bytes | 34 | ··compressed·size:································0·bytes |
| 35 | ··uncompressed·size:······························0·bytes | 35 | ··uncompressed·size:······························0·bytes |
| 36 | ··length·of·filename:·····························16·characters | 36 | ··length·of·filename:·····························16·characters |
| 37 | ··length·of·extra·field:··························36·bytes | 37 | ··length·of·extra·field:··························36·bytes |
| 38 | ··length·of·file·comment:·························0·characters | 38 | ··length·of·file·comment:·························0·characters |
| 39 | ··disk·number·on·which·file·begins:···············disk·1 | 39 | ··disk·number·on·which·file·begins:···············disk·1 |
| 40 | ··apparent·file·type:·····························binary | 40 | ··apparent·file·type:·····························binary |
| 41 | ··non-MSDOS·external·file·attributes:·············000000·hex | 41 | ··non-MSDOS·external·file·attributes:·············000000·hex |
| 42 | ··MS-DOS·file·attributes·(10·hex):················dir· | 42 | ··MS-DOS·file·attributes·(10·hex):················dir· |
| 43 | ··The·central-directory·extra·field·contains: | 43 | ··The·central-directory·extra·field·contains: |
| 44 | ··-·A·subfield·with·ID·0x000a·(PKWARE·Win32)·and·32·data·bytes.··The·first | 44 | ··-·A·subfield·with·ID·0x000a·(PKWARE·Win32)·and·32·data·bytes.··The·first |
| 45 | ····20·are:···00·00·00·00·01·00·18·00· | 45 | ····20·are:···00·00·00·00·01·00·18·00·ac·1d·e0·ca·31·ff·da·01·e1·f1·c9·ce. |
| 46 | ··There·is·no·file·comment. | 46 | ··There·is·no·file·comment. |
| 47 | Central·directory·entry·#2: | 47 | Central·directory·entry·#2: |
| 48 | --------------------------- | 48 | --------------------------- |
| 49 | ··There·are·an·extra·-36·bytes·preceding·this·file. | 49 | ··There·are·an·extra·-36·bytes·preceding·this·file. |
| Offset 60, 46726 lines modified | Offset 60, 49175 lines modified | ||
| 60 | ··version·of·encoding·software:···················3.1 | 60 | ··version·of·encoding·software:···················3.1 |
| 61 | ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT | 61 | ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT |
| 62 | ··minimum·software·version·required·to·extract:···2.0 | 62 | ··minimum·software·version·required·to·extract:···2.0 |
| 63 | ··compression·method:·····························deflated | 63 | ··compression·method:·····························deflated |
| 64 | ··compression·sub-type·(deflation):···············normal | 64 | ··compression·sub-type·(deflation):···············normal |
| 65 | ··file·security·status:···························not·encrypted | 65 | ··file·security·status:···························not·encrypted |
| 66 | ··extended·local·header:··························no | 66 | ··extended·local·header:··························no |
| 67 | ··file·last·modified·on·(DOS·date/time):··········2024·Sep· | 67 | ··file·last·modified·on·(DOS·date/time):··········2024·Sep·4·22:20:20 |
| 68 | ··32-bit·CRC·value·(hex):························· | 68 | ··32-bit·CRC·value·(hex):·························5b29d606 |
| 69 | ··compressed·size:································ | 69 | ··compressed·size:································612·bytes |
| 70 | ··uncompressed·size:······························1 | 70 | ··uncompressed·size:······························1480·bytes |
| 71 | ··length·of·filename:·····························32·characters | 71 | ··length·of·filename:·····························32·characters |
| 72 | ··length·of·extra·field:··························36·bytes | 72 | ··length·of·extra·field:··························36·bytes |
| 73 | ··length·of·file·comment:·························0·characters | 73 | ··length·of·file·comment:·························0·characters |
| 74 | ··disk·number·on·which·file·begins:···············disk·1 | 74 | ··disk·number·on·which·file·begins:···············disk·1 |
| 75 | ··apparent·file·type:·····························binary | 75 | ··apparent·file·type:·····························binary |
| 76 | ··non-MSDOS·external·file·attributes:·············000000·hex | 76 | ··non-MSDOS·external·file·attributes:·············000000·hex |
| 77 | ··MS-DOS·file·attributes·(20·hex):················arc· | 77 | ··MS-DOS·file·attributes·(20·hex):················arc· |
| 78 | ··The·central-directory·extra·field·contains: | 78 | ··The·central-directory·extra·field·contains: |
| 79 | ··-·A·subfield·with·ID·0x000a·(PKWARE·Win32)·and·32·data·bytes.··The·first | 79 | ··-·A·subfield·with·ID·0x000a·(PKWARE·Win32)·and·32·data·bytes.··The·first |
| 80 | ····20·are:···00·00·00·00·01·00·18·00· | 80 | ····20·are:···00·00·00·00·01·00·18·00·9e·cc·85·c6·31·ff·da·01·9e·cc·85·c6. |
| 81 | ··There·is·no·file·comment. | 81 | ··There·is·no·file·comment. |
| 82 | Central·directory·entry·#3: | 82 | Central·directory·entry·#3: |
| 83 | --------------------------- | 83 | --------------------------- |
| 84 | ··There·are·an·extra·-36·bytes·preceding·this·file. | 84 | ··There·are·an·extra·-36·bytes·preceding·this·file. |
| 85 | ··Assembly-CSharp/AbilityButtonSettings.cs | 85 | ··Assembly-CSharp/AbilityButtonSettings.cs |
| 86 | ··offset·of·local·header·from·start·of·archive:···7 | 86 | ··offset·of·local·header·from·start·of·archive:···720 |
| 87 | ··················································(00000000000002 | 87 | ··················································(00000000000002D0h)·bytes |
| 88 | ··file·system·or·operating·system·of·origin:······MS-DOS,·OS/2·or·NT·FAT | 88 | ··file·system·or·operating·system·of·origin:······MS-DOS,·OS/2·or·NT·FAT |
| 89 | ··version·of·encoding·software:···················3.1 | 89 | ··version·of·encoding·software:···················3.1 |
| 90 | ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT | 90 | ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT |
| 91 | ··minimum·software·version·required·to·extract:···2.0 | 91 | ··minimum·software·version·required·to·extract:···2.0 |
| 92 | ··compression·method:·····························deflated | 92 | ··compression·method:·····························deflated |
| 93 | ··compression·sub-type·(deflation):···············normal | 93 | ··compression·sub-type·(deflation):···············normal |
| 94 | ··file·security·status:···························not·encrypted | 94 | ··file·security·status:···························not·encrypted |
| 95 | ··extended·local·header:··························no | 95 | ··extended·local·header:··························no |
| 96 | ··file·last·modified·on·(DOS·date/time):··········2024·Sep· | 96 | ··file·last·modified·on·(DOS·date/time):··········2024·Sep·4·22:20:20 |
| 97 | ··32-bit·CRC·value·(hex):························· | 97 | ··32-bit·CRC·value·(hex):·························4342ee09 |
| 98 | ··compressed·size:································1 | 98 | ··compressed·size:································162·bytes |
| 99 | ··uncompressed·size:······························2 | 99 | ··uncompressed·size:······························237·bytes |
| 100 | ··length·of·filename:·····························40·characters | 100 | ··length·of·filename:·····························40·characters |
| 101 | ··length·of·extra·field:··························36·bytes | 101 | ··length·of·extra·field:··························36·bytes |
| 102 | ··length·of·file·comment:·························0·characters | 102 | ··length·of·file·comment:·························0·characters |
| 103 | ··disk·number·on·which·file·begins:···············disk·1 | 103 | ··disk·number·on·which·file·begins:···············disk·1 |
| 104 | ··apparent·file·type:·····························binary | 104 | ··apparent·file·type:·····························binary |
| 105 | ··non-MSDOS·external·file·attributes:·············000000·hex | 105 | ··non-MSDOS·external·file·attributes:·············000000·hex |
| 106 | ··MS-DOS·file·attributes·(20·hex):················arc· | 106 | ··MS-DOS·file·attributes·(20·hex):················arc· |
| 107 | ··The·central-directory·extra·field·contains: | 107 | ··The·central-directory·extra·field·contains: |
| 108 | ··-·A·subfield·with·ID·0x000a·(PKWARE·Win32)·and·32·data·bytes.··The·first | 108 | ··-·A·subfield·with·ID·0x000a·(PKWARE·Win32)·and·32·data·bytes.··The·first |
| 109 | ····20·are:···00·00·00·00·01·00·18·00· | 109 | ····20·are:···00·00·00·00·01·00·18·00·c9·41·86·c6·31·ff·da·01·c9·41·86·c6. |
| 110 | ··There·is·no·file·comment. | 110 | ··There·is·no·file·comment. |
| 111 | Central·directory·entry·#4: | 111 | Central·directory·entry·#4: |
| 112 | --------------------------- | 112 | --------------------------- |
| 113 | ··There·are·an·extra·-36·bytes·preceding·this·file. | 113 | ··There·are·an·extra·-36·bytes·preceding·this·file. |
| 114 | ··Assembly-CSharp/AbstractChatInputField.cs | 114 | ··Assembly-CSharp/AbstractChatInputField.cs |
| 115 | ··offset·of·local·header·from·start·of·archive:···9 | 115 | ··offset·of·local·header·from·start·of·archive:···952 |
| 116 | ··················································(00000000000003 | 116 | ··················································(00000000000003B8h)·bytes |
| 117 | ··file·system·or·operating·system·of·origin:······MS-DOS,·OS/2·or·NT·FAT | 117 | ··file·system·or·operating·system·of·origin:······MS-DOS,·OS/2·or·NT·FAT |
| 118 | ··version·of·encoding·software:···················3.1 | 118 | ··version·of·encoding·software:···················3.1 |
| 119 | ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT | 119 | ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT |
| 120 | ··minimum·software·version·required·to·extract:···2.0 | 120 | ··minimum·software·version·required·to·extract:···2.0 |
| 121 | ··compression·method:·····························deflated | 121 | ··compression·method:·····························deflated |
| Max diff block lines reached; 2850150/2857576 bytes (99.74%) of diff not shown. | |||
| Offset 51, 15 lines modified | Offset 51, 15 lines modified | ||
| 51 | Filename:·Assembly-CSharp/AdjustSteeringGame.cs | 51 | Filename:·Assembly-CSharp/AdjustSteeringGame.cs |
| 52 | Comment:· | 52 | Comment:· |
| 53 | Filename:·Assembly-CSharp/AdminButton.cs | 53 | Filename:·Assembly-CSharp/AdminButton.cs |
| 54 | Comment:· | 54 | Comment:· |
| 55 | Filename:·Assembly-CSharp/AdvancedRole | 55 | Filename:·Assembly-CSharp/AdvancedRoleViewPanel.cs |
| 56 | Comment:· | 56 | Comment:· |
| 57 | Filename:·Assembly-CSharp/AgeGateScreen.cs | 57 | Filename:·Assembly-CSharp/AgeGateScreen.cs |
| 58 | Comment:· | 58 | Comment:· |
| 59 | Filename:·Assembly-CSharp/AirshipAuthGame.cs | 59 | Filename:·Assembly-CSharp/AirshipAuthGame.cs |
| 60 | Comment:· | 60 | Comment:· |
| Offset 93, 14 lines modified | Offset 93, 71 lines modified | ||
| 93 | Filename:·Assembly-CSharp/AmbientSoundPlayer.cs | 93 | Filename:·Assembly-CSharp/AmbientSoundPlayer.cs |
| 94 | Comment:· | 94 | Comment:· |
| 95 | Filename:·Assembly-CSharp/Amongus/ | 95 | Filename:·Assembly-CSharp/Amongus/ |
| 96 | Comment:· | 96 | Comment:· |
| 97 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/ | ||
| 98 | Comment:· | ||
| 99 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AbstractAnimationTestScenePage.cs | ||
| 100 | Comment:· | ||
| 101 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestScene.cs | ||
| 102 | Comment:· | ||
| 103 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneButton.cs | ||
| 104 | Comment:· | ||
| 105 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneColorsPage.cs | ||
| 106 | Comment:· | ||
| 107 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneColorsPageBuilder.cs | ||
| 108 | Comment:· | ||
| 109 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneColorsPageBuilderPresetButton.cs | ||
| 110 | Comment:· | ||
| 111 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneColorsPageBuilderSprite.cs | ||
| 112 | Comment:· | ||
| 113 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneColorsPageRenderer.cs | ||
| 114 | Comment:· | ||
| 115 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneCosmeticData.cs | ||
| 116 | Comment:· | ||
| 117 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneEjectPage.cs | ||
| 118 | Comment:· | ||
| 119 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneExitPage.cs | ||
| 120 | Comment:· | ||
| 121 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneInfoPage.cs | ||
| 122 | Comment:· | ||
| 123 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneKillPage.cs | ||
| 124 | Comment:· | ||
| 125 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneMeetingPage.cs | ||
| 126 | Comment:· | ||
| 127 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestScenePetsPage.cs | ||
| 128 | Comment:· | ||
| 129 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestScenePlayerPage.cs | ||
| 130 | Comment:· | ||
| 131 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestScenePlayerPageBodyToggle.cs | ||
| 132 | Comment:· | ||
| 133 | Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneTab.cs | ||
| 134 | Comment:· | ||
| 97 | Filename:·Assembly-CSharp/Amongus/Data/ | 135 | Filename:·Assembly-CSharp/Amongus/Data/ |
| 98 | Comment:· | 136 | Comment:· |
| 99 | Filename:·Assembly-CSharp/Amongus/Data/AbstractSaveData.cs | 137 | Filename:·Assembly-CSharp/Amongus/Data/AbstractSaveData.cs |
| 100 | Comment:· | 138 | Comment:· |
| 101 | Filename:·Assembly-CSharp/Amongus/Data/AbstractSaveDataGroup.cs | 139 | Filename:·Assembly-CSharp/Amongus/Data/AbstractSaveDataGroup.cs |
| Offset 201, 14 lines modified | Offset 258, 17 lines modified | ||
| 201 | Filename:·Assembly-CSharp/Amongus/GameOptions/ByteOptionNames.cs | 258 | Filename:·Assembly-CSharp/Amongus/GameOptions/ByteOptionNames.cs |
| 202 | Comment:· | 259 | Comment:· |
| 203 | Filename:·Assembly-CSharp/Amongus/GameOptions/EngineerRoleOptionsV07.cs | 260 | Filename:·Assembly-CSharp/Amongus/GameOptions/EngineerRoleOptionsV07.cs |
| 204 | Comment:· | 261 | Comment:· |
| 262 | Filename:·Assembly-CSharp/Amongus/GameOptions/EngineerRoleOptionsV08.cs | ||
| 263 | Comment:· | ||
| 205 | Filename:·Assembly-CSharp/Amongus/GameOptions/FloatArrayOptionNames.cs | 264 | Filename:·Assembly-CSharp/Amongus/GameOptions/FloatArrayOptionNames.cs |
| 206 | Comment:· | 265 | Comment:· |
| 207 | Filename:·Assembly-CSharp/Amongus/GameOptions/FloatOptionNames.cs | 266 | Filename:·Assembly-CSharp/Amongus/GameOptions/FloatOptionNames.cs |
| 208 | Comment:· | 267 | Comment:· |
| 209 | Filename:·Assembly-CSharp/Amongus/GameOptions/GameKeywords.cs | 268 | Filename:·Assembly-CSharp/Amongus/GameOptions/GameKeywords.cs |
| Offset 222, 20 lines modified | Offset 282, 29 lines modified | ||
| 222 | Filename:·Assembly-CSharp/Amongus/GameOptions/GameOptionsFactory.cs | 282 | Filename:·Assembly-CSharp/Amongus/GameOptions/GameOptionsFactory.cs |
| 223 | Comment:· | 283 | Comment:· |
| 224 | Filename:·Assembly-CSharp/Amongus/GameOptions/GameOptionsMigratorV06toV07.cs | 284 | Filename:·Assembly-CSharp/Amongus/GameOptions/GameOptionsMigratorV06toV07.cs |
| 225 | Comment:· | 285 | Comment:· |
| 286 | Filename:·Assembly-CSharp/Amongus/GameOptions/GameOptionsMigratorV07toV08.cs | ||
| 287 | Comment:· | ||
| 226 | Filename:·Assembly-CSharp/Amongus/GameOptions/GuardianAngelRoleOptionsV07.cs | 288 | Filename:·Assembly-CSharp/Amongus/GameOptions/GuardianAngelRoleOptionsV07.cs |
| 227 | Comment:· | 289 | Comment:· |
| 290 | Filename:·Assembly-CSharp/Amongus/GameOptions/GuardianAngelRoleOptionsV08.cs | ||
| 291 | Comment:· | ||
| 228 | Filename:·Assembly-CSharp/Amongus/GameOptions/HideNSeekGameOptionsV07.cs | 292 | Filename:·Assembly-CSharp/Amongus/GameOptions/HideNSeekGameOptionsV07.cs |
| 229 | Comment:· | 293 | Comment:· |
| 294 | Filename:·Assembly-CSharp/Amongus/GameOptions/HideNSeekGameOptionsV08.cs | ||
| 295 | Comment:· | ||
| Max diff block lines reached; 13925/17717 bytes (78.60%) of diff not shown. | |||
| Offset 1, 67599 lines modified | Offset 1, 71149 lines modified | ||
| 1 | 000000·LOCAL·HEADER·#1·······04034B50 | 1 | 000000·LOCAL·HEADER·#1·······04034B50 |
| 2 | 000004·Extract·Zip·Spec······0A·'1.0' | 2 | 000004·Extract·Zip·Spec······0A·'1.0' |
| 3 | 000005·Extract·OS············00·'MS-DOS' | 3 | 000005·Extract·OS············00·'MS-DOS' |
| 4 | 000006·General·Purpose·Flag··0000 | 4 | 000006·General·Purpose·Flag··0000 |
| 5 | 000008·Compression·Method····0000·'Stored' | 5 | 000008·Compression·Method····0000·'Stored' |
| 6 | 00000A·Last·Mod·Time·········592 | 6 | 00000A·Last·Mod·Time·········5924B28E·'Wed·Sep··4·22:20:28·2024' |
| 7 | 00000E·CRC···················00000000 | 7 | 00000E·CRC···················00000000 |
| 8 | 000012·Compressed·Length·····00000000 | 8 | 000012·Compressed·Length·····00000000 |
| 9 | 000016·Uncompressed·Length···00000000 | 9 | 000016·Uncompressed·Length···00000000 |
| 10 | 00001A·Filename·Length·······0010 | 10 | 00001A·Filename·Length·······0010 |
| 11 | 00001C·Extra·Length··········0000 | 11 | 00001C·Extra·Length··········0000 |
| 12 | 00001E·Filename··············'XXXXXXXXXXXXXXX/' | 12 | 00001E·Filename··············'XXXXXXXXXXXXXXX/' |
| 13 | 00002E·LOCAL·HEADER·#2·······04034B50 | 13 | 00002E·LOCAL·HEADER·#2·······04034B50 |
| 14 | 000032·Extract·Zip·Spec······14·'2.0' | 14 | 000032·Extract·Zip·Spec······14·'2.0' |
| 15 | 000033·Extract·OS············00·'MS-DOS' | 15 | 000033·Extract·OS············00·'MS-DOS' |
| 16 | 000034·General·Purpose·Flag··0000 | 16 | 000034·General·Purpose·Flag··0000 |
| 17 | ·······[Bits·1-2]············0·'Normal·Compression' | 17 | ·······[Bits·1-2]············0·'Normal·Compression' |
| 18 | 000036·Compression·Method····0008·'Deflated' | 18 | 000036·Compression·Method····0008·'Deflated' |
| 19 | 000038·Last·Mod·Time·········592 | 19 | 000038·Last·Mod·Time·········5924B28A·'Wed·Sep··4·22:20:20·2024' |
| 20 | 00003C·CRC··················· | 20 | 00003C·CRC···················5B29D606 |
| 21 | 000040·Compressed·Length·····000002 | 21 | 000040·Compressed·Length·····00000264 |
| 22 | 000044·Uncompressed·Length···000005 | 22 | 000044·Uncompressed·Length···000005C8 |
| 23 | 000048·Filename·Length·······0020 | 23 | 000048·Filename·Length·······0020 |
| 24 | 00004A·Extra·Length··········0000 | 24 | 00004A·Extra·Length··········0000 |
| 25 | 00004C·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXX' | 25 | 00004C·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXX' |
| 26 | 00006C·PAYLOAD | 26 | 00006C·PAYLOAD |
| 27 | 0002 | 27 | 0002D0·LOCAL·HEADER·#3·······04034B50 |
| 28 | 0002 | 28 | 0002D4·Extract·Zip·Spec······14·'2.0' |
| 29 | 0002 | 29 | 0002D5·Extract·OS············00·'MS-DOS' |
| 30 | 0002 | 30 | 0002D6·General·Purpose·Flag··0000 |
| 31 | ·······[Bits·1-2]············0·'Normal·Compression' | 31 | ·······[Bits·1-2]············0·'Normal·Compression' |
| 32 | 0002 | 32 | 0002D8·Compression·Method····0008·'Deflated' |
| 33 | 0002 | 33 | 0002DA·Last·Mod·Time·········5924B28A·'Wed·Sep··4·22:20:20·2024' |
| 34 | 0002 | 34 | 0002DE·CRC···················4342EE09 |
| 35 | 0002 | 35 | 0002E2·Compressed·Length·····000000A2 |
| 36 | 0002 | 36 | 0002E6·Uncompressed·Length···000000ED |
| 37 | 0002 | 37 | 0002EA·Filename·Length·······0028 |
| 38 | 0002 | 38 | 0002EC·Extra·Length··········0000 |
| 39 | 0002 | 39 | 0002EE·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX |
| 40 | ·····························X' | 40 | ·····························X' |
| 41 | 0003 | 41 | 000316·PAYLOAD···············XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX |
| 42 | ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX | 42 | ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX |
| 43 | ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX | 43 | ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX |
| 44 | ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX | 44 | ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX |
| 45 | ·····························XX | ||
| 45 | 0003 | 46 | 0003B8·LOCAL·HEADER·#4·······04034B50 |
| 46 | 0003 | 47 | 0003BC·Extract·Zip·Spec······14·'2.0' |
| 47 | 0003 | 48 | 0003BD·Extract·OS············00·'MS-DOS' |
| 48 | 0003 | 49 | 0003BE·General·Purpose·Flag··0000 |
| 49 | ·······[Bits·1-2]············0·'Normal·Compression' | 50 | ·······[Bits·1-2]············0·'Normal·Compression' |
| 50 | 0003 | 51 | 0003C0·Compression·Method····0008·'Deflated' |
| 51 | 0003 | 52 | 0003C2·Last·Mod·Time·········5924B28A·'Wed·Sep··4·22:20:20·2024' |
| 52 | 0003 | 53 | 0003C6·CRC···················F9135BBF |
| 53 | 0003 | 54 | 0003CA·Compressed·Length·····000002FE |
| 54 | 0003 | 55 | 0003CE·Uncompressed·Length···0000097C |
| 55 | 0003 | 56 | 0003D2·Filename·Length·······0029 |
| 56 | 0003 | 57 | 0003D4·Extra·Length··········0000 |
| 57 | 0003 | 58 | 0003D6·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX |
| 58 | ·····························XX' | 59 | ·····························XX' |
| 59 | 0003 | 60 | 0003FF·PAYLOAD |
| 60 | 0006 | 61 | 0006FD·LOCAL·HEADER·#5·······04034B50 |
| 61 | 000 | 62 | 000701·Extract·Zip·Spec······14·'2.0' |
| 62 | 000 | 63 | 000702·Extract·OS············00·'MS-DOS' |
| 63 | 000 | 64 | 000703·General·Purpose·Flag··0000 |
| 64 | ·······[Bits·1-2]············0·'Normal·Compression' | 65 | ·······[Bits·1-2]············0·'Normal·Compression' |
| 65 | 000 | 66 | 000705·Compression·Method····0008·'Deflated' |
| 66 | 000 | 67 | 000707·Last·Mod·Time·········5924B288·'Wed·Sep··4·22:20:16·2024' |
| 67 | 000 | 68 | 00070B·CRC···················BFAB7C8F |
| 68 | 000 | 69 | 00070F·Compressed·Length·····00000125 |
| 69 | 000 | 70 | 000713·Uncompressed·Length···00000289 |
| 70 | 000 | 71 | 000717·Filename·Length·······0028 |
| 71 | 000 | 72 | 000719·Extra·Length··········0000 |
| 72 | 0007 | 73 | 00071B·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX |
| 73 | ·····························X' | 74 | ·····························X' |
| 74 | 0007 | 75 | 000743·PAYLOAD |
| 75 | 0008 | 76 | 000868·LOCAL·HEADER·#6·······04034B50 |
| 76 | 0008 | 77 | 00086C·Extract·Zip·Spec······14·'2.0' |
| 77 | 0008 | 78 | 00086D·Extract·OS············00·'MS-DOS' |
| 78 | 0008 | 79 | 00086E·General·Purpose·Flag··0000 |
| 79 | ·······[Bits·1-2]············0·'Normal·Compression' | 80 | ·······[Bits·1-2]············0·'Normal·Compression' |
| 80 | 0008 | 81 | 000870·Compression·Method····0008·'Deflated' |
| 81 | 0008 | 82 | 000872·Last·Mod·Time·········5924B289·'Wed·Sep··4·22:20:18·2024' |
| 82 | 0008 | 83 | 000876·CRC···················B10C949C |
| 83 | 0008 | 84 | 00087A·Compressed·Length·····00000067 |
| 84 | 0008 | 85 | 00087E·Uncompressed·Length···00000070 |
| 85 | 0008 | 86 | 000882·Filename·Length·······002D |
| 86 | 0008 | 87 | 000884·Extra·Length··········0000 |
| 87 | 0008 | 88 | 000886·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX |
| 88 | ·····························XXXXXX' | 89 | ·····························XXXXXX' |
| 89 | 0008 | 90 | 0008B3·PAYLOAD···············XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX |
| 90 | ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX | 91 | ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX |
| 91 | ·····························XXXXXXXXXXXXXXXXXXXXXXX | 92 | ·····························XXXXXXXXXXXXXXXXXXXXXXX |
| 92 | 000 | 93 | 00091A·LOCAL·HEADER·#7·······04034B50 |
| 93 | 000 | 94 | 00091E·Extract·Zip·Spec······14·'2.0' |
| 94 | 000 | 95 | 00091F·Extract·OS············00·'MS-DOS' |
| 95 | 000 | 96 | 000920·General·Purpose·Flag··0000 |
| 96 | ·······[Bits·1-2]············0·'Normal·Compression' | 97 | ·······[Bits·1-2]············0·'Normal·Compression' |
| 97 | 000 | 98 | 000922·Compression·Method····0008·'Deflated' |
| 98 | 000 | 99 | 000924·Last·Mod·Time·········5924B28B·'Wed·Sep··4·22:20:22·2024' |
| 99 | 000 | 100 | 000928·CRC···················33E98826 |
| 100 | 0009 | 101 | 00092C·Compressed·Length·····000003EA |
| 101 | 0009 | 102 | 000930·Uncompressed·Length···00000B73 |
| 102 | 0009 | 103 | 000934·Filename·Length·······0028 |
| 103 | 0009 | 104 | 000936·Extra·Length··········0000 |
| 104 | 0009 | 105 | 000938·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX |
| 105 | ·····························X' | 106 | ·····························X' |
| 106 | 0009 | 107 | 000960·PAYLOAD |
| 107 | 000D | 108 | 000D4A·LOCAL·HEADER·#8·······04034B50 |
| 108 | 000D | 109 | 000D4E·Extract·Zip·Spec······14·'2.0' |
| 109 | 000D | 110 | 000D4F·Extract·OS············00·'MS-DOS' |
| 110 | 000D | 111 | 000D50·General·Purpose·Flag··0000 |
| 111 | ·······[Bits·1-2]············0·'Normal·Compression' | 112 | ·······[Bits·1-2]············0·'Normal·Compression' |
| 112 | 000D | 113 | 000D52·Compression·Method····0008·'Deflated' |
| 113 | 000D | 114 | 000D54·Last·Mod·Time·········5924B287·'Wed·Sep··4·22:20:14·2024' |
| 114 | 000D | 115 | 000D58·CRC···················53019761 |
| 115 | 000D | 116 | 000D5C·Compressed·Length·····00000109 |
| 116 | 000D | 117 | 000D60·Uncompressed·Length···000001B5 |
| 117 | 000D | 118 | 000D64·Filename·Length·······0020 |
| 118 | 000D | 119 | 000D66·Extra·Length··········0000 |
| Max diff block lines reached; 5750386/5763437 bytes (99.77%) of diff not shown. | |||
| Offset 40, 14 lines modified | Offset 40, 20 lines modified | ||
| 40 | » » base.SetInfiniteUses(); | 40 | » » base.SetInfiniteUses(); |
| 41 | » » this.graphic.sprite·=·settings.Image; | 41 | » » this.graphic.sprite·=·settings.Image; |
| 42 | » » this.graphic.SetCooldownNormalizedUvs(); | 42 | » » this.graphic.SetCooldownNormalizedUvs(); |
| 43 | » » this.buttonLabelText.fontSharedMaterial·=·settings.FontMaterial; | 43 | » » this.buttonLabelText.fontSharedMaterial·=·settings.FontMaterial; |
| 44 | » » this.buttonLabelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(settings.Text,·Array.Empty<object>()); | 44 | » » this.buttonLabelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(settings.Text,·Array.Empty<object>()); |
| 45 | » } | 45 | » } |
| 46 | 46 | ||
| 47 | » public·void·SetSecondImage(AbilityButtonSettings·settings) | ||
| 48 | » { | ||
| 49 | » » this.graphic.sprite·=·settings.SecondImage; | ||
| 50 | » » this.graphic.SetCooldownNormalizedUvs(); | ||
| 51 | » } | ||
| 52 | |||
| 47 | » private·void·Update() | 53 | » private·void·Update() |
| 48 | » { | 54 | » { |
| 49 | » » if·(PlayerControl.LocalPlayer.Data.Role.IsAffectedByComms) | 55 | » » if·(PlayerControl.LocalPlayer.Data.Role.IsAffectedByComms) |
| 50 | » » { | 56 | » » { |
| 51 | » » » this.commsDown.SetActive(true); | 57 | » » » this.commsDown.SetActive(true); |
| 52 | » » » return; | 58 | » » » return; |
| 53 | » » } | 59 | » » } |
| Offset 2, 11 lines modified | Offset 2, 13 lines modified | ||
| 2 | using·UnityEngine; | 2 | using·UnityEngine; |
| 3 | 3 | ||
| 4 | [CreateAssetMenu] | 4 | [CreateAssetMenu] |
| 5 | public·class·AbilityButtonSettings·:·ScriptableObject | 5 | public·class·AbilityButtonSettings·:·ScriptableObject |
| 6 | { | 6 | { |
| 7 | » public·Sprite·Image; | 7 | » public·Sprite·Image; |
| 8 | 8 | ||
| 9 | » public·Sprite·SecondImage; | ||
| 10 | |||
| 9 | » public·StringNames·Text; | 11 | » public·StringNames·Text; |
| 10 | 12 | ||
| 11 | » public·Material·FontMaterial; | 13 | » public·Material·FontMaterial; |
| 12 | } | 14 | } |
| Offset 26, 10 lines modified | Offset 26, 15 lines modified | ||
| 26 | » } | 26 | » } |
| 27 | 27 | ||
| 28 | » public·bool·Contains(string·id) | 28 | » public·bool·Contains(string·id) |
| 29 | » { | 29 | » { |
| 30 | » » return·this.ids.Contains(id); | 30 | » » return·this.ids.Contains(id); |
| 31 | » } | 31 | » } |
| 32 | 32 | ||
| 33 | » public·int·IndexOf(CosmeticData·cosmetic) | ||
| 34 | » { | ||
| 35 | » » return·this.ids.IndexOf(cosmetic.ProductId); | ||
| 36 | » } | ||
| 37 | |||
| 33 | » [SerializeField] | 38 | » [SerializeField] |
| 34 | » private·List<string>·ids·=·new·List<string>(); | 39 | » private·List<string>·ids·=·new·List<string>(); |
| 35 | } | 40 | } |
| Offset 175, 26 lines modified | Offset 175, 29 lines modified | ||
| 175 | » } | 175 | » } |
| 176 | 176 | ||
| 177 | » private·void·UpdateAccountIDDisplay() | 177 | » private·void·UpdateAccountIDDisplay() |
| 178 | » { | 178 | » { |
| 179 | » » if·(string.IsNullOrEmpty(DestroyableSingleton<EOSManager>.Instance.ProductUserId)) | 179 | » » if·(string.IsNullOrEmpty(DestroyableSingleton<EOSManager>.Instance.ProductUserId)) |
| 180 | » » { | 180 | » » { |
| 181 | » » » this.showAccountID·=·false; | 181 | » » » this.showAccountID·=·false; |
| 182 | » » » this.accountCopyButton.SetActive(false); | ||
| 182 | » » » this.showAccountIDButton.gameObject.SetActive(false); | 183 | » » » this.showAccountIDButton.gameObject.SetActive(false); |
| 183 | » » » this.accountIDDisplayText.text·=·""; | 184 | » » » this.accountIDDisplayText.text·=·""; |
| 184 | » » » return; | 185 | » » » return; |
| 185 | » » } | 186 | » » } |
| 186 | » » if·(this.showAccountID) | 187 | » » if·(this.showAccountID) |
| 187 | » » { | 188 | » » { |
| 188 | » » » this.accountIDDisplayText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.AccountIDDisplay,·new·object[]·{·DestroyableSingleton<EOSManager>.Instance.ProductUserId·}); | 189 | » » » this.accountIDDisplayText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.AccountIDDisplay,·new·object[]·{·DestroyableSingleton<EOSManager>.Instance.ProductUserId·}); |
| 189 | » » » this.showAccountIDButton.gameObject.SetActive(false); | 190 | » » » this.showAccountIDButton.gameObject.SetActive(false); |
| 191 | » » » this.accountCopyButton.SetActive(true); | ||
| 190 | » » » return; | 192 | » » » return; |
| 191 | » » } | 193 | » » } |
| 192 | » » this.showAccountIDButton.gameObject.SetActive(true); | 194 | » » this.showAccountIDButton.gameObject.SetActive(true); |
| 193 | » » this.accountIDDisplayText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.AccountIDDisplay,·new·object[]·{·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.HiddenAccountID,·Array.Empty<object>())·}); | 195 | » » this.accountIDDisplayText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.AccountIDDisplay,·new·object[]·{·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.HiddenAccountID,·Array.Empty<object>())·}); |
| 196 | » » this.accountCopyButton.SetActive(false); | ||
| 194 | » } | 197 | » } |
| 195 | 198 | ||
| 196 | » public·void·HideAccountIDDisplay() | 199 | » public·void·HideAccountIDDisplay() |
| 197 | » { | 200 | » { |
| 198 | » » this.showAccountID·=·false; | 201 | » » this.showAccountID·=·false; |
| 199 | » » this.UpdateAccountIDDisplay(); | 202 | » » this.UpdateAccountIDDisplay(); |
| 200 | » } | 203 | » } |
| Offset 317, 14 lines modified | Offset 320, 17 lines modified | ||
| 317 | » public·SpriteRenderer·SpaceHorse; | 320 | » public·SpriteRenderer·SpaceHorse; |
| 318 | 321 | ||
| 319 | » public·InfoTextBox·InfoTextBoxDisplay; | 322 | » public·InfoTextBox·InfoTextBoxDisplay; |
| 320 | 323 | ||
| 321 | » [SerializeField] | 324 | » [SerializeField] |
| 322 | » private·SignInStatusComponent·signInStatusComponent; | 325 | » private·SignInStatusComponent·signInStatusComponent; |
| 323 | 326 | ||
| 327 | » [SerializeField] | ||
| 328 | » private·GameObject·accountCopyButton; | ||
| 329 | |||
| 324 | » private·bool·showAccountID; | 330 | » private·bool·showAccountID; |
| 325 | 331 | ||
| 326 | » private·string·friendCodeHiddenText·=·"XXXXXXXXXX"; | 332 | » private·string·friendCodeHiddenText·=·"XXXXXXXXXX"; |
| 327 | 333 | ||
| 328 | » [Header("Console·Controller·Navigation")] | 334 | » [Header("Console·Controller·Navigation")] |
| 329 | » public·UiElement·BackButton; | 335 | » public·UiElement·BackButton; |
| 330 | 336 | ||
| Offset 137, 28 lines modified | Offset 137, 28 lines modified | ||
| 137 | » { | 137 | » { |
| 138 | » » if·(!this.gameStarted) | 138 | » » if·(!this.gameStarted) |
| 139 | » » { | 139 | » » { |
| 140 | » » » return; | 140 | » » » return; |
| 141 | » » } | 141 | » » } |
| 142 | » » this.logger.Info("Match·ended",·null); | 142 | » » this.logger.Info("Match·ended",·null); |
| 143 | » » this.gameStarted·=·false; | 143 | » » this.gameStarted·=·false; |
| 144 | » » GameData.PlayerInfo·data·=·PlayerControl.LocalPlayer.Data; | ||
| 145 | » » | 144 | » » CachedPlayerData·cachedLocalPlayer·=·EndGameResult.CachedLocalPlayer; |
| 145 | » » bool·flag·=·cachedLocalPlayer·!=·null·&&·cachedLocalPlayer.IsImpostor; | ||
| 146 | » » if·(flag) | 146 | » » if·(flag) |
| 147 | » » { | 147 | » » { |
| 148 | » » » if·(this.ventsUsedThisMatch·==·0·&&·GameManager.Instance.DidImpostorsWin(reason)) | 148 | » » » if·(this.ventsUsedThisMatch·==·0·&&·GameManager.Instance.DidImpostorsWin(reason)) |
| 149 | » » » { | 149 | » » » { |
| 150 | » » » » this.UnlockAchievement("no_vents_impostor_win"); | 150 | » » » » this.UnlockAchievement("no_vents_impostor_win"); |
| 151 | » » » } | 151 | » » » } |
| 152 | » » » IEnumerable< | 152 | » » » IEnumerable<NetworkedPlayerInfo>·enumerable·=·Enumerable.Where<NetworkedPlayerInfo>(GameData.Instance.AllPlayers,·(NetworkedPlayerInfo·p)·=>·p.Role.IsImpostor); |
| 153 | » » » int·num·=·Enumerable.Count< | 153 | » » » int·num·=·Enumerable.Count<NetworkedPlayerInfo>(enumerable); |
| 154 | » » » bool·flag2; | 154 | » » » bool·flag2; |
| 155 | » » » if·(num·==·2) | 155 | » » » if·(num·==·2) |
| 156 | » » » { | 156 | » » » { |
| 157 | » » » » flag2·=·num·==·Enumerable.Count< | 157 | » » » » flag2·=·num·==·Enumerable.Count<NetworkedPlayerInfo>(enumerable,·(NetworkedPlayerInfo·p)·=>·!p.IsDead·&&·!p.Disconnected); |
| 158 | » » » } | 158 | » » » } |
| 159 | » » » else | 159 | » » » else |
| 160 | » » » { | 160 | » » » { |
| 161 | » » » » flag2·=·false; | 161 | » » » » flag2·=·false; |
| 162 | » » » } | 162 | » » » } |
| 163 | » » » if·(flag2·&&·didWin) | 163 | » » » if·(flag2·&&·didWin) |
| 164 | » » » { | 164 | » » » { |
| Offset 182, 16 lines modified | Offset 182, 16 lines modified | ||
| 182 | » » » } | 182 | » » » } |
| 183 | » » } | 183 | » » } |
| 184 | » » else | 184 | » » else |
| 185 | » » { | 185 | » » { |
| 186 | » » » if·(GameManager.Instance.DidHumansWin(reason)) | 186 | » » » if·(GameManager.Instance.DidHumansWin(reason)) |
| 187 | » » » { | 187 | » » » { |
| 188 | » » » » this.UpdateAchievementProgress("hnsCrewmateWin",·1); | 188 | » » » » this.UpdateAchievementProgress("hnsCrewmateWin",·1); |
| 189 | » » » » GameData.PlayerInfo·data2·=·PlayerControl.LocalPlayer.Data; | ||
| 190 | » » » » | 189 | » » » » CachedPlayerData·cachedLocalPlayer2·=·EndGameResult.CachedLocalPlayer; |
| 190 | » » » » if·(cachedLocalPlayer2·!=·null·&&·!cachedLocalPlayer2.IsDead) | ||
| 191 | » » » » { | 191 | » » » » { |
| 192 | » » » » » this.UnlockAchievement("survive_crewmate"); | 192 | » » » » » this.UnlockAchievement("survive_crewmate"); |
| 193 | » » » » » this.UnlockAchievement("hns_survive_crewmate"); | 193 | » » » » » this.UnlockAchievement("hns_survive_crewmate"); |
| 194 | » » » » } | 194 | » » » » } |
| 195 | » » » } | 195 | » » » } |
| 196 | » » » if·(reason·==·GameOverReason.HumansByTask) | 196 | » » » if·(reason·==·GameOverReason.HumansByTask) |
| 197 | » » » { | 197 | » » » { |
| Offset 302, 15 lines modified | Offset 302, 15 lines modified | ||
| 302 | » } | 302 | » } |
| 303 | 303 | ||
| 304 | » public·void·OnProtectACrewmate() | 304 | » public·void·OnProtectACrewmate() |
| 305 | » { | 305 | » { |
| 306 | » » this.UnlockAchievement("block_kill_as_guardian"); | 306 | » » this.UnlockAchievement("block_kill_as_guardian"); |
| 307 | » } | 307 | » } |
| 308 | 308 | ||
| 309 | » public·void·OnMeetingVote( | 309 | » public·void·OnMeetingVote(NetworkedPlayerInfo·self,·NetworkedPlayerInfo·target) |
| 310 | » { | 310 | » { |
| 311 | » » if·(!this.gameStarted) | 311 | » » if·(!this.gameStarted) |
| 312 | » » { | 312 | » » { |
| 313 | » » » return; | 313 | » » » return; |
| 314 | » » } | 314 | » » } |
| 315 | » » if·(target·==·null) | 315 | » » if·(target·==·null) |
| 316 | » » { | 316 | » » { |
| Offset 1, 13 lines modified | Offset 1, 21 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·TMPro; | 2 | using·TMPro; |
| 3 | using·UnityEngine; | 3 | using·UnityEngine; |
| 4 | 4 | ||
| 5 | public·abstract·class·ActionButton·:·MonoBehaviour | 5 | public·abstract·class·ActionButton·:·MonoBehaviour |
| 6 | { | 6 | { |
| 7 | » public·bool·IsOnCooldown | ||
| 8 | » { | ||
| 9 | » » get | ||
| 10 | » » { | ||
| 11 | » » » return·this.isCoolingDown; | ||
| 12 | » » } | ||
| 13 | » } | ||
| 14 | |||
| 7 | » private·void·Start() | 15 | » private·void·Start() |
| 8 | » { | 16 | » { |
| 9 | » » this.position·=·this.graphic.transform.localPosition; | 17 | » » this.position·=·this.graphic.transform.localPosition; |
| 10 | » } | 18 | » } |
| 11 | 19 | ||
| 12 | » public·abstract·void·DoClick(); | 20 | » public·abstract·void·DoClick(); |
| 13 | 21 | ||
| Offset 1, 58 lines modified | Offset 1, 88 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·UnityEngine; | 2 | using·UnityEngine; |
| 3 | using·UnityEngine.UI; | ||
| 3 | 4 | ||
| 4 | [RequireComponent(typeof(SpriteRenderer))] | ||
| 5 | public·class·ActionMapGlyphDisplay·:·MonoBehaviour | 5 | public·class·ActionMapGlyphDisplay·:·MonoBehaviour |
| 6 | { | 6 | { |
| 7 | » private·void·Awake() | 7 | » private·void·Awake() |
| 8 | » { | 8 | » { |
| 9 | » » this.sr·=·base.GetComponent<SpriteRenderer>(); | 9 | » » this.spriteRenderer·=·base.GetComponent<SpriteRenderer>(); |
| 10 | » » this.uiImage·=·base.GetComponent<Image>(); | ||
| 10 | » » this.UpdateGlyphDisplay(); | 11 | » » this.UpdateGlyphDisplay(); |
| 11 | » » ActiveInputManager.CurrentInputSourceChanged·=·(Action)Delegate.Combine(ActiveInputManager.CurrentInputSourceChanged,·new·Action(this.UpdateGlyphDisplay)); | 12 | » » ActiveInputManager.CurrentInputSourceChanged·=·(Action)Delegate.Combine(ActiveInputManager.CurrentInputSourceChanged,·new·Action(this.UpdateGlyphDisplay)); |
| 12 | » } | 13 | » } |
| 13 | 14 | ||
| 14 | » private·void·OnDestroy() | 15 | » private·void·OnDestroy() |
| 15 | » { | 16 | » { |
| 16 | » » ActiveInputManager.CurrentInputSourceChanged·=·(Action)Delegate.Remove(ActiveInputManager.CurrentInputSourceChanged,·new·Action(this.UpdateGlyphDisplay)); | 17 | » » ActiveInputManager.CurrentInputSourceChanged·=·(Action)Delegate.Remove(ActiveInputManager.CurrentInputSourceChanged,·new·Action(this.UpdateGlyphDisplay)); |
| 17 | » } | 18 | » } |
| 18 | 19 | ||
| 19 | » public·void·UpdateGlyphDisplay() | 20 | » public·void·UpdateGlyphDisplay() |
| 20 | » { | 21 | » { |
| 21 | » » if·(this.sr) | 22 | » » if·(this.spriteRenderer) |
| 22 | » » { | 23 | » » { |
| 23 | » » » this.sr.gameObject.SetActive(false); | 24 | » » » this.spriteRenderer.gameObject.SetActive(false); |
| 24 | » » } | 25 | » » } |
| 26 | » » if·(this.uiImage) | ||
| 27 | » » { | ||
| 28 | » » » this.uiImage.gameObject.SetActive(false); | ||
| 29 | » » } | ||
| 25 | » » if·(ActiveInputManager.currentControlType·==·ActiveInputManager.InputType.Joystick | 30 | » » if·(ActiveInputManager.currentControlType·==·ActiveInputManager.InputType.Joystick) |
| 26 | » » { | 31 | » » { |
| 27 | » » » this.sr.gameObject.SetActive(true); | ||
| 28 | » » » GlyphCollection.ErrorCode·errorCode; | 32 | » » » GlyphCollection.ErrorCode·errorCode; |
| 29 | » » » Sprite·sprite·=·GlyphCollection.FindGlyph((int)this.actionToDisplayMappedGlyphFor,·out·errorCode); | 33 | » » » Sprite·sprite·=·GlyphCollection.FindGlyph((int)this.actionToDisplayMappedGlyphFor,·out·errorCode); |
| 30 | » » » if·( | 34 | » » » if·(this.spriteRenderer) |
| 31 | » » » { | 35 | » » » { |
| 36 | » » » » this.spriteRenderer.gameObject.SetActive(true); | ||
| 37 | » » » » if·(errorCode·!=·GlyphCollection.ErrorCode.NoController) | ||
| 38 | » » » » { | ||
| 39 | » » » » » this.spriteRenderer.sprite·=·sprite; | ||
| 40 | » » » » } | ||
| 41 | » » » » else | ||
| 42 | » » » » { | ||
| 43 | » » » » » this.spriteRenderer.gameObject.SetActive(false); | ||
| 44 | » » » » } | ||
| 45 | » » » } | ||
| 46 | » » » if·(this.uiImage) | ||
| 47 | » » » { | ||
| 48 | » » » » this.uiImage.gameObject.SetActive(true); | ||
| 49 | » » » » if·(errorCode·!=·GlyphCollection.ErrorCode.NoController) | ||
| 50 | » » » » { | ||
| 32 | » » » » this. | 51 | » » » » » this.uiImage.sprite·=·sprite; |
| 33 | » » » » return; | 52 | » » » » » return; |
| 53 | » » » » } | ||
| 54 | » » » » this.uiImage.gameObject.SetActive(false); | ||
| 34 | » » » } | 55 | » » » } |
| 35 | » » » this.sr.gameObject.SetActive(false); | ||
| 36 | » » } | 56 | » » } |
| 37 | » } | 57 | » } |
| 38 | 58 | ||
| 39 | » public·void·SetColor(Color·color) | 59 | » public·void·SetColor(Color·color) |
| 40 | » { | 60 | » { |
| 41 | » » if·(this.sr) | 61 | » » if·(this.spriteRenderer) |
| 42 | » » { | 62 | » » { |
| 63 | » » » this.spriteRenderer.color·=·color; | ||
| 64 | » » } | ||
| 65 | » » if·(this.uiImage) | ||
| 66 | » » { | ||
| 43 | » » » this. | 67 | » » » this.uiImage.color·=·color; |
| 44 | » » } | 68 | » » } |
| 45 | » } | 69 | » } |
| 46 | 70 | ||
| 47 | » public·void·SetSpriteVisibility(bool·visible) | 71 | » public·void·SetSpriteVisibility(bool·visible) |
| 48 | » { | 72 | » { |
| 73 | » » if·(this.spriteRenderer·!=·null) | ||
| 74 | » » { | ||
| 75 | » » » this.spriteRenderer.enabled·=·visible; | ||
| 76 | » » } | ||
| 49 | » » if·(this. | 77 | » » if·(this.uiImage·!=·null) |
| 50 | » » { | 78 | » » { |
| 51 | » » » this. | 79 | » » » this.uiImage.enabled·=·visible; |
| 52 | » » } | 80 | » » } |
| 53 | » } | 81 | » } |
| 54 | 82 | ||
| 55 | » public·RewiredConstsEnum.Action·actionToDisplayMappedGlyphFor; | 83 | » public·RewiredConstsEnum.Action·actionToDisplayMappedGlyphFor; |
| 56 | 84 | ||
| 57 | » private·SpriteRenderer·sr; | 85 | » private·SpriteRenderer·spriteRenderer; |
| 86 | |||
| 87 | » private·Image·uiImage; | ||
| 58 | } | 88 | } |
| Offset 2, 36 lines modified | Offset 2, 46 lines modified | ||
| 2 | using·System.Collections; | 2 | using·System.Collections; |
| 3 | using·UnityEngine; | 3 | using·UnityEngine; |
| 4 | 4 | ||
| 5 | public·class·AirshipExileController·:·ExileController | 5 | public·class·AirshipExileController·:·ExileController |
| 6 | { | 6 | { |
| 7 | » protected·override·IEnumerator·Animate() | 7 | » protected·override·IEnumerator·Animate() |
| 8 | » { | 8 | » { |
| 9 | » » if·(this. | 9 | » » if·(this.initData·!=·null·&&·this.initData.outfit·!=·null) |
| 10 | » » { | 10 | » » { |
| 11 | » » » PlayerMaterial.SetColors(this. | 11 | » » » PlayerMaterial.SetColors(this.initData.outfit.ColorId,·this.HandSlot); |
| 12 | » » } | 12 | » » } |
| 13 | » » float·num·=·0.7f·+·this.Duration·+·0.5f·+·2f; | 13 | » » float·num·=·0.7f·+·this.Duration·+·0.5f·+·2f; |
| 14 | » » base.StartCoroutine(Effects.All(new·IEnumerator[] | 14 | » » base.StartCoroutine(Effects.All(new·IEnumerator[] |
| 15 | » » { | 15 | » » { |
| 16 | » » » this.SlowMoSlide2D(this.ForegroundCloud.transform,·new·Vector2(-1.4f,·-2.41f),·new·Vector2(-0.4f,·-2.41f),·num), | 16 | » » » this.SlowMoSlide2D(this.ForegroundCloud.transform,·new·Vector2(-1.4f,·-2.41f),·new·Vector2(-0.4f,·-2.41f),·num), |
| 17 | » » » this.SlowMoSlide2D(this.BackgroundCloud.transform,·new·Vector2(-0.97f,·-1.043f),·new·Vector2(0.25f,·-1.043f),·num), | 17 | » » » this.SlowMoSlide2D(this.BackgroundCloud.transform,·new·Vector2(-0.97f,·-1.043f),·new·Vector2(0.25f,·-1.043f),·num), |
| 18 | » » » this.SlowMoSlide2D(this.Cloud1.transform,·new·Vector2(3f,·0.25f),·new·Vector2(6.5f,·0.25f),·num), | 18 | » » » this.SlowMoSlide2D(this.Cloud1.transform,·new·Vector2(3f,·0.25f),·new·Vector2(6.5f,·0.25f),·num), |
| 19 | » » » this.SlowMoSlide2D(this.Cloud2.transform,·new·Vector2(-6f,·3f),·new·Vector2(5f,·3f),·num), | 19 | » » » this.SlowMoSlide2D(this.Cloud2.transform,·new·Vector2(-6f,·3f),·new·Vector2(5f,·3f),·num), |
| 20 | » » » this.SlowMoSlide2D(this.Cloud3.transform,·new·Vector2(-4f,·-2.2f),·new·Vector2(4f,·-2.2f),·num) | 20 | » » » this.SlowMoSlide2D(this.Cloud3.transform,·new·Vector2(-4f,·-2.2f),·new·Vector2(4f,·-2.2f),·num) |
| 21 | » » })); | 21 | » » })); |
| 22 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | ||
| 23 | » » { | ||
| 22 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false); | 24 | » » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false); |
| 25 | » » } | ||
| 23 | » » yield·return·Effects.Wait(0.5f); | 26 | » » yield·return·Effects.Wait(0.5f); |
| 24 | » » yield·return·Effects.All(new·IEnumerator[] | 27 | » » yield·return·Effects.All(new·IEnumerator[] |
| 25 | » » { | 28 | » » { |
| 26 | » » » this.PlayerFall(), | 29 | » » » this.PlayerFall(), |
| 27 | » » » this.HandleText(1.75f,·this.Duration·*·0.5f) | 30 | » » » this.HandleText(1.75f,·this.Duration·*·0.5f) |
| 28 | » » }); | 31 | » » }); |
| 29 | » » yield·return·new·WaitForSeconds(0.5f); | 32 | » » yield·return·new·WaitForSeconds(0.5f); |
| 33 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | ||
| 34 | » » { | ||
| 30 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false); | 35 | » » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false); |
| 36 | » » } | ||
| 37 | » » else | ||
| 38 | » » { | ||
| 39 | » » » yield·return·Effects.Wait(0.2f); | ||
| 40 | » » } | ||
| 31 | » » yield·return·this.WrapUpAndSpawn(); | 41 | » » yield·return·this.WrapUpAndSpawn(); |
| 32 | » » yield·break; | 42 | » » yield·break; |
| 33 | » } | 43 | » } |
| 34 | 44 | ||
| 35 | » private·IEnumerator·SlowMoSlide2D(Transform·target,·Vector2·source,·Vector2·dest,·float·duration) | 45 | » private·IEnumerator·SlowMoSlide2D(Transform·target,·Vector2·source,·Vector2·dest,·float·duration) |
| 36 | » { | 46 | » { |
| 37 | » » Vector3·temp·=·default(Vector3); | 47 | » » Vector3·temp·=·default(Vector3); |
| Offset 48, 36 lines modified | Offset 58, 36 lines modified | ||
| 48 | » » temp.y·=·dest.y; | 58 | » » temp.y·=·dest.y; |
| 49 | » » target.localPosition·=·temp; | 59 | » » target.localPosition·=·temp; |
| 50 | » » yield·break; | 60 | » » yield·break; |
| 51 | » } | 61 | » } |
| 52 | 62 | ||
| 53 | » protected·IEnumerator·WrapUpAndSpawn() | 63 | » protected·IEnumerator·WrapUpAndSpawn() |
| 54 | » { | 64 | » { |
| 55 | » » if·(this. | 65 | » » if·(this.initData·!=·null·&&·this.initData.networkedPlayer·!=·null) |
| 56 | » » { | 66 | » » { |
| 57 | » » » PlayerControl·@object·=·this.e | 67 | » » » PlayerControl·@object·=·this.initData.networkedPlayer.Object; |
| 58 | » » » if·(@object) | 68 | » » » if·(@object) |
| 59 | » » » { | 69 | » » » { |
| 60 | » » » » @object.Exiled(); | 70 | » » » » @object.Exiled(); |
| 61 | » » » } | 71 | » » » } |
| 62 | » » » this.e | 72 | » » » this.initData.networkedPlayer.IsDead·=·true; |
| 63 | » » } | 73 | » » } |
| 64 | » » if·(DestroyableSingleton<TutorialManager>.InstanceExists·||·!GameManager.Instance.LogicFlow.IsGameOverDueToDeath()) | 74 | » » if·(DestroyableSingleton<TutorialManager>.InstanceExists·||·(GameManager.Instance·!=·null·&&·!GameManager.Instance.LogicFlow.IsGameOverDueToDeath())) |
| 65 | » » { | 75 | » » { |
| 66 | » » » yield·return·ShipStatus.Instance.PrespawnStep(); | 76 | » » » yield·return·ShipStatus.Instance.PrespawnStep(); |
| 67 | » » » base.ReEnableGameplay(); | 77 | » » » base.ReEnableGameplay(); |
| 68 | » » } | 78 | » » } |
| 69 | » » Object.Destroy(base.gameObject); | 79 | » » Object.Destroy(base.gameObject); |
| 70 | » » yield·break; | 80 | » » yield·break; |
| 71 | » } | 81 | » } |
| 72 | 82 | ||
| 73 | » protected·override·IEnumerator·HandleText(float·firstWaitTime,·float·animDuration) | 83 | » protected·override·IEnumerator·HandleText(float·firstWaitTime,·float·animDuration) |
| 74 | » { | 84 | » { |
| 75 | » » yield·return·Effects.Wait(firstWaitTime); | 85 | » » yield·return·Effects.Wait(firstWaitTime); |
| 76 | » » if·(this. | 86 | » » if·(this.initData·!=·null·&&·this.initData.outfit·!=·null) |
| 77 | » » { | 87 | » » { |
| 78 | » » » this.CloudSlowMo·=·0.1f; | 88 | » » » this.CloudSlowMo·=·0.1f; |
| 79 | » » » this.PlayerSlowMo·=·0.1f; | 89 | » » » this.PlayerSlowMo·=·0.1f; |
| 80 | » » » SoundManager.Instance.PlaySound(this.Stinger,·false,·1f,·null); | 90 | » » » SoundManager.Instance.PlaySound(this.Stinger,·false,·1f,·null); |
| 81 | » » } | 91 | » » } |
| 82 | » » float·newDur·=·this.Duration·*·0.5f; | 92 | » » float·newDur·=·this.Duration·*·0.5f; |
| 83 | » » for·(float·t·=·0f;·t·<=·newDur;·t·+=·Time.deltaTime) | 93 | » » for·(float·t·=·0f;·t·<=·newDur;·t·+=·Time.deltaTime) |
| Offset 95, 15 lines modified | Offset 105, 15 lines modified | ||
| 95 | » » » yield·return·null; | 105 | » » » yield·return·null; |
| 96 | » » } | 106 | » » } |
| 97 | » » this.Text.text·=·this.completeString; | 107 | » » this.Text.text·=·this.completeString; |
| 98 | » » yield·return·Effects.Wait(1f); | 108 | » » yield·return·Effects.Wait(1f); |
| 99 | » » this.CloudSlowMo·=·1f; | 109 | » » this.CloudSlowMo·=·1f; |
| 100 | » » this.PlayerSlowMo·=·6f; | 110 | » » this.PlayerSlowMo·=·6f; |
| 101 | » » yield·return·Effects.Wait(0.5f); | 111 | » » yield·return·Effects.Wait(0.5f); |
| 102 | » » if·( | 112 | » » if·(this.initData.confirmImpostor) |
| 103 | » » { | 113 | » » { |
| 104 | » » » this.ImpostorText.gameObject.SetActive(true); | 114 | » » » this.ImpostorText.gameObject.SetActive(true); |
| 105 | » » } | 115 | » » } |
| 106 | » » yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f); | 116 | » » yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f); |
| 107 | » » yield·break; | 117 | » » yield·break; |
| 108 | » } | 118 | » } |
| 109 | 119 | ||
| Offset 73, 15 lines modified | Offset 73, 15 lines modified | ||
| 73 | » } | 73 | » } |
| 74 | 74 | ||
| 75 | » public·override·void·RepairCriticalSabotages() | 75 | » public·override·void·RepairCriticalSabotages() |
| 76 | » { | 76 | » { |
| 77 | » » (ShipStatus.Instance.Systems[SystemTypes.HeliSabotage]·as·HeliSabotageSystem).ClearSabotage(); | 77 | » » (ShipStatus.Instance.Systems[SystemTypes.HeliSabotage]·as·HeliSabotageSystem).ClearSabotage(); |
| 78 | » } | 78 | » } |
| 79 | 79 | ||
| 80 | » public·override·float·CalculateLightRadius( | 80 | » public·override·float·CalculateLightRadius(NetworkedPlayerInfo·player) |
| 81 | » { | 81 | » { |
| 82 | » » float·num·=·base.CalculateLightRadius(player); | 82 | » » float·num·=·base.CalculateLightRadius(player); |
| 83 | » » if·(player.Role.AffectedByLightAffectors) | 83 | » » if·(player.Role.AffectedByLightAffectors) |
| 84 | » » { | 84 | » » { |
| 85 | » » » foreach·(LightAffector·lightAffector·in·this.LightAffectors) | 85 | » » » foreach·(LightAffector·lightAffector·in·this.LightAffectors) |
| 86 | » » » { | 86 | » » » { |
| 87 | » » » » if·(player.Object·&&·player.Object.Collider.IsTouching(lightAffector.Hitbox)) | 87 | » » » » if·(player.Object·&&·player.Object.Collider.IsTouching(lightAffector.Hitbox)) |
| Offset 127, 23 lines modified | Offset 127, 23 lines modified | ||
| 127 | » » » » DataManager.Logger.Error("[PlayerData::OnSaveStart()]·Failed·to·serialize·and·encrypt·PlayerAdsData.",·null); | 127 | » » » » DataManager.Logger.Error("[PlayerData::OnSaveStart()]·Failed·to·serialize·and·encrypt·PlayerAdsData.",·null); |
| 128 | » » » } | 128 | » » » } |
| 129 | » » } | 129 | » » } |
| 130 | 130 | ||
| 131 | » » protected·override·void·OnLoadComplete() | 131 | » » protected·override·void·OnLoadComplete() |
| 132 | » » { | 132 | » » { |
| 133 | » » » base.OnLoadComplete(); | 133 | » » » base.OnLoadComplete(); |
| 134 | » » » this.purchases.UpdateLegacyPurchases(); | ||
| 135 | » » » if·(this.encryptedAge·!=·null·&&·this.encryptedAge.Length·!=·0) | 134 | » » » if·(this.encryptedAge·!=·null·&&·this.encryptedAge.Length·!=·0) |
| 136 | » » » { | 135 | » » » { |
| 137 | » » » » base.TryDecryptAndDeserialize<PlayerAgeData>(ref·this.age,·this.encryptedAge); | 136 | » » » » base.TryDecryptAndDeserialize<PlayerAgeData>(ref·this.age,·this.encryptedAge); |
| 138 | » » » } | 137 | » » » } |
| 139 | » » » if·(this.encryptedStore·!=·null·&&·this.encryptedStore.Length·!=·0) | 138 | » » » if·(this.encryptedStore·!=·null·&&·this.encryptedStore.Length·!=·0) |
| 140 | » » » { | 139 | » » » { |
| 141 | » » » » base.TryDecryptAndDeserialize<PlayerStoreData>(ref·this.store,·this.encryptedStore); | 140 | » » » » base.TryDecryptAndDeserialize<PlayerStoreData>(ref·this.store,·this.encryptedStore); |
| 142 | » » » } | 141 | » » » } |
| 142 | » » » this.purchases.UpdateLegacyPurchases(); | ||
| 143 | » » » if·(this.encryptedAds·!=·null·&&·this.encryptedAds.Length·!=·0) | 143 | » » » if·(this.encryptedAds·!=·null·&&·this.encryptedAds.Length·!=·0) |
| 144 | » » » { | 144 | » » » { |
| 145 | » » » » base.TryDecryptAndDeserialize<PlayerAdsData>(ref·this.ads,·this.encryptedAds); | 145 | » » » » base.TryDecryptAndDeserialize<PlayerAdsData>(ref·this.ads,·this.encryptedAds); |
| 146 | » » » } | 146 | » » » } |
| 147 | » » } | 147 | » » } |
| 148 | 148 | ||
| 149 | » » protected·override·void·HandleVersionMigration(int·version) | 149 | » » protected·override·void·HandleVersionMigration(int·version) |
| Offset 177, 15 lines modified | Offset 177, 15 lines modified | ||
| 177 | » » » » » } | 177 | » » » » » } |
| 178 | » » » » » int[]·array·=·LegacySaveManager.LoadLocalDoB(); | 178 | » » » » » int[]·array·=·LegacySaveManager.LoadLocalDoB(); |
| 179 | » » » » » if·(array.Length·==·3·&&·array[0]·>·0·&&·array[1]·>·0·&&·array[2]·>·0) | 179 | » » » » » if·(array.Length·==·3·&&·array[0]·>·0·&&·array[1]·>·0·&&·array[2]·>·0) |
| 180 | » » » » » { | 180 | » » » » » { |
| 181 | » » » » » » this.Age.DateOfBirth·=·new·DateTime(array[0],·array[1],·array[2]); | 181 | » » » » » » this.Age.DateOfBirth·=·new·DateTime(array[0],·array[1],·array[2]); |
| 182 | » » » » » } | 182 | » » » » » } |
| 183 | » » » » » this.Store.ActiveCosmicube·=·LegacySaveManager.LastCosmicube; | 183 | » » » » » this.Store.ActiveCosmicube·=·LegacySaveManager.LastCosmicube; |
| 184 | » » » » » this.Store. | 184 | » » » » » this.Store.MigrateLegacyPurchases(); |
| 185 | » » » » » if·(LegacySaveManager.StoreTabViewDatesFileExists()) | 185 | » » » » » if·(LegacySaveManager.StoreTabViewDatesFileExists()) |
| 186 | » » » » » { | 186 | » » » » » { |
| 187 | » » » » » » foreach·(object·obj·in·Enum.GetValues(typeof(StoreTab))) | 187 | » » » » » » foreach·(object·obj·in·Enum.GetValues(typeof(StoreTab))) |
| 188 | » » » » » » { | 188 | » » » » » » { |
| 189 | » » » » » » » StoreTab·storeTab·=·(StoreTab)obj; | 189 | » » » » » » » StoreTab·storeTab·=·(StoreTab)obj; |
| 190 | » » » » » » » string·text; | 190 | » » » » » » » string·text; |
| 191 | » » » » » » » if·(LegacySaveManager.TryGetStoreTabViewDate(storeTab,·out·text)) | 191 | » » » » » » » if·(LegacySaveManager.TryGetStoreTabViewDate(storeTab,·out·text)) |
| Offset 177, 48 lines modified | Offset 177, 51 lines modified | ||
| 177 | » » » case·StoreTab.Nameplates: | 177 | » » » case·StoreTab.Nameplates: |
| 178 | » » » » this.LastNameplatesViewDate·=·val; | 178 | » » » » this.LastNameplatesViewDate·=·val; |
| 179 | » » » » return; | 179 | » » » » return; |
| 180 | » » » } | 180 | » » » } |
| 181 | » » » Debug.LogError(string.Format("[{0}]·{1}.{2}·has·not·been·configured.",·"PlayerStoreData",·"StoreTab",·tab)); | 181 | » » » Debug.LogError(string.Format("[{0}]·{1}.{2}·has·not·been·configured.",·"PlayerStoreData",·"StoreTab",·tab)); |
| 182 | » » } | 182 | » » } |
| 183 | 183 | ||
| 184 | » » public·void· | 184 | » » public·void·MigrateLegacyPurchases() |
| 185 | » » { | 185 | » » { |
| 186 | » » » foreach·(string·text·in·PlayerStoreData.LEGACY_PURCHASE_KEYS) | 186 | » » » foreach·(string·text·in·PlayerStoreData.LEGACY_PURCHASE_KEYS) |
| 187 | » » » { | 187 | » » » { |
| 188 | » » » » this.Try | 188 | » » » » this.TryMigrateLegacyUnlock(text); |
| 189 | » » » } | 189 | » » » } |
| 190 | » » } | 190 | » » } |
| 191 | 191 | ||
| 192 | » » private·void·Try | 192 | » » private·void·TryMigrateLegacyUnlock(string·key) |
| 193 | » » { | 193 | » » { |
| 194 | » » » if·(LegacySaveManager.GetPurchase(key,·null)) | 194 | » » » if·(LegacySaveManager.GetPurchase(key,·null)) |
| 195 | » » » { | 195 | » » » { |
| 196 | » » » » this.AddLegacyPurchases(new·string[]·{·key·}); | ||
| 196 | » » » » if·(string.IsNullOrEmpty(key)) | ||
| 197 | » » » » { | ||
| 198 | » » » » » return; | ||
| 199 | » » » » } | ||
| 200 | » » » » if·(this.legacyPurchases.Contains(key)) | ||
| 201 | » » » » { | ||
| 202 | » » » » » return; | ||
| 203 | » » » » } | ||
| 204 | » » » » this.legacyPurchases.Add(key); | ||
| 205 | » » » } | 197 | » » » } |
| 206 | » » } | 198 | » » } |
| 207 | 199 | ||
| 208 | » » public·bool·HasLegacyPurchase(string·key) | 200 | » » public·bool·HasLegacyPurchase(string·key) |
| 209 | » » { | 201 | » » { |
| 210 | » » » return·this.legacyPurchases.Contains(key); | 202 | » » » return·this.legacyPurchases.Contains(key); |
| 211 | » » } | 203 | » » } |
| 212 | 204 | ||
| 213 | » » public·string[]·GetLegacyPurchases() | 205 | » » public·string[]·GetLegacyPurchases() |
| 214 | » » { | 206 | » » { |
| 215 | » » » return·this.legacyPurchases.ToArray(); | 207 | » » » return·this.legacyPurchases.ToArray(); |
| 216 | » » } | 208 | » » } |
| 217 | 209 | ||
| 210 | » » public·void·AddLegacyPurchases(params·string[]·keys) | ||
| 211 | » » { | ||
| 212 | » » » foreach·(string·text·in·keys) | ||
| 213 | » » » { | ||
| 214 | » » » » if·(!string.IsNullOrEmpty(text)·&&·!this.legacyPurchases.Contains(text)) | ||
| 215 | » » » » { | ||
| 216 | » » » » » this.legacyPurchases.Add(text); | ||
| 217 | » » » » } | ||
| 218 | » » » } | ||
| 219 | » » } | ||
| 220 | |||
| 218 | » » public·const·string·DEFAULT_ACTIVE_COSMICUBE·=·""; | 221 | » » public·const·string·DEFAULT_ACTIVE_COSMICUBE·=·""; |
| 219 | 222 | ||
| 220 | » » public·static·readonly·DateTime·DEFAULT_LAST_VIEW_DATE·=·DateTime.MinValue; | 223 | » » public·static·readonly·DateTime·DEFAULT_LAST_VIEW_DATE·=·DateTime.MinValue; |
| 221 | 224 | ||
| 222 | » » [JsonProperty("activeCosmicube")] | 225 | » » [JsonProperty("activeCosmicube")] |
| 223 | » » private·string·activeCosmicube·=·""; | 226 | » » private·string·activeCosmicube·=·""; |
| 224 | 227 | ||
| Offset 12, 10 lines modified | Offset 12, 11 lines modified | ||
| 12 | » » IsDefaults, | 12 | » » IsDefaults, |
| 13 | » » UseFlashlight, | 13 | » » UseFlashlight, |
| 14 | » » SeekerFinalVents, | 14 | » » SeekerFinalVents, |
| 15 | » » SeekerFinalMap, | 15 | » » SeekerFinalMap, |
| 16 | » » SeekerPings, | 16 | » » SeekerPings, |
| 17 | » » ShowCrewmateNames, | 17 | » » ShowCrewmateNames, |
| 18 | » » ShapeshifterLeaveSkin·=·1000, | 18 | » » ShapeshifterLeaveSkin·=·1000, |
| 19 | » » ImpostorsCanSeeProtect·=·1100 | 19 | » » ImpostorsCanSeeProtect·=·1100, |
| 20 | » » NoisemakerImpostorAlert·=·1300 | ||
| 20 | » } | 21 | » } |
| 21 | } | 22 | } |
| Offset 19, 10 lines modified | Offset 19, 16 lines modified | ||
| 19 | » » ShapeshifterCooldown·=·1000, | 19 | » » ShapeshifterCooldown·=·1000, |
| 20 | » » ShapeshifterDuration, | 20 | » » ShapeshifterDuration, |
| 21 | » » ProtectionDurationSeconds·=·1100, | 21 | » » ProtectionDurationSeconds·=·1100, |
| 22 | » » GuardianAngelCooldown, | 22 | » » GuardianAngelCooldown, |
| 23 | » » ScientistCooldown·=·1200, | 23 | » » ScientistCooldown·=·1200, |
| 24 | » » ScientistBatteryCharge, | 24 | » » ScientistBatteryCharge, |
| 25 | » » EngineerCooldown·=·1300, | 25 | » » EngineerCooldown·=·1300, |
| 26 | » » EngineerInVentMaxTime | 26 | » » EngineerInVentMaxTime, |
| 27 | » » PhantomCooldown·=·1500, | ||
| 28 | » » PhantomDuration, | ||
| 29 | » » TrackerCooldown·=·1550, | ||
| 30 | » » TrackerDuration, | ||
| 31 | » » TrackerDelay, | ||
| 32 | » » NoisemakerAlertDuration·=·1600 | ||
| 27 | » } | 33 | » } |
| 28 | } | 34 | } |
| Offset 1, 15 lines modified | Offset 1, 15 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·Newtonsoft.Json; | 2 | using·Newtonsoft.Json; |
| 3 | using·Newtonsoft.Json.Converters; | 3 | using·Newtonsoft.Json.Converters; |
| 4 | 4 | ||
| 5 | namespace·AmongUs.GameOptions | 5 | namespace·AmongUs.GameOptions |
| 6 | { | 6 | { |
| 7 | » [JsonConverter(typeof(StringEnumConverter))] | ||
| 8 | » [Flags] | 7 | » [Flags] |
| 8 | » [JsonConverter(typeof(StringEnumConverter))] | ||
| 9 | » public·enum·GameKeywords·:·uint | 9 | » public·enum·GameKeywords·:·uint |
| 10 | » { | 10 | » { |
| 11 | » » All·=·0U, | 11 | » » All·=·0U, |
| 12 | » » English·=·256U, | 12 | » » English·=·256U, |
| 13 | » » SpanishLA·=·2U, | 13 | » » SpanishLA·=·2U, |
| 14 | » » Brazilian·=·2048U, | 14 | » » Brazilian·=·2048U, |
| 15 | » » Portuguese·=·16U, | 15 | » » Portuguese·=·16U, |
| Offset 6, 14 lines modified | Offset 6, 22 lines modified | ||
| 6 | { | 6 | { |
| 7 | » public·class·GameOptionsData·:·IGameOptions | 7 | » public·class·GameOptionsData·:·IGameOptions |
| 8 | » { | 8 | » { |
| 9 | » » public·byte·Version·{·get;·private·set;·}·=·6; | 9 | » » public·byte·Version·{·get;·private·set;·}·=·6; |
| 10 | 10 | ||
| 11 | » » public·GameModes·GameMode·{·get;·private·set;·}·=·GameModes.Normal; | 11 | » » public·GameModes·GameMode·{·get;·private·set;·}·=·GameModes.Normal; |
| 12 | 12 | ||
| 13 | » » public·SpecialGameModes·SpecialMode | ||
| 14 | » » { | ||
| 15 | » » » get | ||
| 16 | » » » { | ||
| 17 | » » » » return·SpecialGameModes.None; | ||
| 18 | » » » } | ||
| 19 | » » } | ||
| 20 | |||
| 13 | » » public·GameModes·AprilFoolsOnMode | 21 | » » public·GameModes·AprilFoolsOnMode |
| 14 | » » { | 22 | » » { |
| 15 | » » » get | 23 | » » » get |
| 16 | » » » { | 24 | » » » { |
| 17 | » » » » return·GameModes.NormalFools; | 25 | » » » » return·GameModes.NormalFools; |
| 18 | » » » } | 26 | » » » } |
| 19 | » » } | 27 | » » } |
| Offset 22, 14 lines modified | Offset 30, 16 lines modified | ||
| 22 | » » { | 30 | » » { |
| 23 | » » » get | 31 | » » » get |
| 24 | » » » { | 32 | » » » { |
| 25 | » » » » return·GameModes.Normal; | 33 | » » » » return·GameModes.Normal; |
| 26 | » » » } | 34 | » » » } |
| 27 | » » } | 35 | » » } |
| 28 | 36 | ||
| 37 | » » public·RulesPresets·RulesPreset·{·get;·set;·} | ||
| 38 | |||
| 29 | » » public·int·MaxPlayers·{·get;·private·set;·}·=·10; | 39 | » » public·int·MaxPlayers·{·get;·private·set;·}·=·10; |
| 30 | 40 | ||
| 31 | » » public·GameKeywords·Keywords·{·get;·private·set;·}·=·GameKeywords.English; | 41 | » » public·GameKeywords·Keywords·{·get;·private·set;·}·=·GameKeywords.English; |
| 32 | 42 | ||
| 33 | » » public·byte·MapId·{·get;·private·set;·} | 43 | » » public·byte·MapId·{·get;·private·set;·} |
| 34 | 44 | ||
| 35 | » » public·IRoleOptionsCollection·RoleOptions | 45 | » » public·IRoleOptionsCollection·RoleOptions |
| Offset 184, 14 lines modified | Offset 194, 18 lines modified | ||
| 184 | » » » this.roleOptions.ScientistBatteryCharge·=·5f; | 194 | » » » this.roleOptions.ScientistBatteryCharge·=·5f; |
| 185 | » » » this.roleOptions.GuardianAngelCooldown·=·60f; | 195 | » » » this.roleOptions.GuardianAngelCooldown·=·60f; |
| 186 | » » » this.roleOptions.ProtectionDurationSeconds·=·10f; | 196 | » » » this.roleOptions.ProtectionDurationSeconds·=·10f; |
| 187 | » » » this.roleOptions.EngineerCooldown·=·30f; | 197 | » » » this.roleOptions.EngineerCooldown·=·30f; |
| 188 | » » » this.roleOptions.EngineerInVentMaxTime·=·15f; | 198 | » » » this.roleOptions.EngineerInVentMaxTime·=·15f; |
| 189 | » » } | 199 | » » } |
| 190 | 200 | ||
| 201 | » » public·void·SetRecommendations(int·numPlayers,·bool·isOnline,·RulesPresets·rulesPresets) | ||
| 202 | » » { | ||
| 203 | » » } | ||
| 204 | |||
| 191 | » » public·bool·Validate(int·numPlayers) | 205 | » » public·bool·Validate(int·numPlayers) |
| 192 | » » { | 206 | » » { |
| 193 | » » » bool·flag·=·false; | 207 | » » » bool·flag·=·false; |
| 194 | » » » if·(this.NumCommonTasks·+·this.NumLongTasks·+·this.NumShortTasks·==·0) | 208 | » » » if·(this.NumCommonTasks·+·this.NumLongTasks·+·this.NumShortTasks·==·0) |
| 195 | » » » { | 209 | » » » { |
| 196 | » » » » this.NumShortTasks·=·1; | 210 | » » » » this.NumShortTasks·=·1; |
| 197 | » » » » flag·=·true; | 211 | » » » » flag·=·true; |
| Offset 126, 50 lines modified | Offset 126, 70 lines modified | ||
| 126 | » » » » this.logger.WriteError(string.Format("Could·not·parse·options·data·for·game·mode·{0}",·gameModes)); | 126 | » » » » this.logger.WriteError(string.Format("Could·not·parse·options·data·for·game·mode·{0}",·gameModes)); |
| 127 | » » » » return·null; | 127 | » » » » return·null; |
| 128 | » » » } | 128 | » » » } |
| 129 | » » } | 129 | » » } |
| 130 | 130 | ||
| 131 | » » private·void·NormalModeToWriter(MessageWriter·writer,·IGameOptions·optionsData) | 131 | » » private·void·NormalModeToWriter(MessageWriter·writer,·IGameOptions·optionsData) |
| 132 | » » { | 132 | » » { |
| 133 | » » » i | 133 | » » » byte·version·=·optionsData.Version; |
| 134 | » » » if·(version·==·7) | ||
| 134 | » » » { | 135 | » » » { |
| 135 | » » » » NormalGameOptionsV07.Serialize(writer,·optionsData·as·NormalGameOptionsV07); | 136 | » » » » NormalGameOptionsV07.Serialize(writer,·optionsData·as·NormalGameOptionsV07); |
| 136 | » » » » return; | 137 | » » » » return; |
| 137 | » » » } | 138 | » » » } |
| 139 | » » » if·(version·!=·8) | ||
| 140 | » » » { | ||
| 138 | » » » this.logger.WriteError(string.Format("Could·not·serialize·normal·options·data·for·version·{0}",·optionsData.Version)); | 141 | » » » » this.logger.WriteError(string.Format("Could·not·serialize·normal·options·data·for·version·{0}",·optionsData.Version)); |
| 142 | » » » » return; | ||
| 143 | » » » } | ||
| 144 | » » » NormalGameOptionsV08.Serialize(writer,·optionsData·as·NormalGameOptionsV08); | ||
| 139 | » » } | 145 | » » } |
| 140 | 146 | ||
| 141 | » » private·void·HideNSeekModeToWriter(MessageWriter·writer,·IGameOptions·optionsData) | 147 | » » private·void·HideNSeekModeToWriter(MessageWriter·writer,·IGameOptions·optionsData) |
| 142 | » » { | 148 | » » { |
| 143 | » » » i | 149 | » » » byte·version·=·optionsData.Version; |
| 150 | » » » if·(version·==·7) | ||
| 144 | » » » { | 151 | » » » { |
| 145 | » » » » HideNSeekGameOptionsV07.Serialize(writer,·optionsData·as·HideNSeekGameOptionsV07); | 152 | » » » » HideNSeekGameOptionsV07.Serialize(writer,·optionsData·as·HideNSeekGameOptionsV07); |
| 146 | » » » » return; | 153 | » » » » return; |
| 147 | » » » } | 154 | » » » } |
| 155 | » » » if·(version·!=·8) | ||
| 156 | » » » { | ||
| 148 | » » » this.logger.WriteError(string.Format("Could·not·serialize·hidenseek·options·data·for·version·{0}",·optionsData.Version)); | 157 | » » » » this.logger.WriteError(string.Format("Could·not·serialize·hidenseek·options·data·for·version·{0}",·optionsData.Version)); |
| 158 | » » » » return; | ||
| 159 | » » » } | ||
| 160 | » » » HideNSeekGameOptionsV08.Serialize(writer,·optionsData·as·HideNSeekGameOptionsV08); | ||
| 149 | » » } | 161 | » » } |
| 150 | 162 | ||
| 151 | » » private·IGameOptions·NormalModeFromBytes(MessageReader·reader,·byte·version,·bool·isAprilFoolsMode) | 163 | » » private·IGameOptions·NormalModeFromBytes(MessageReader·reader,·byte·version,·bool·isAprilFoolsMode) |
| 152 | » » { | 164 | » » { |
| 153 | » » » if·(version·==·7) | 165 | » » » if·(version·==·7) |
| 154 | » » » { | 166 | » » » { |
| 155 | » » » » return·NormalGameOptionsV07.Deserialize(reader,·isAprilFoolsMode,·this.logger); | 167 | » » » » return·NormalGameOptionsV07.Deserialize(reader,·isAprilFoolsMode,·this.logger); |
| 156 | » » » } | 168 | » » » } |
| 169 | » » » if·(version·!=·8) | ||
| 170 | » » » { | ||
| 157 | » » » this.logger.WriteError(string.Format("Could·not·parse·normal·game·options·for·version·{0}",·version)); | 171 | » » » » this.logger.WriteError(string.Format("Could·not·parse·normal·game·options·for·version·{0}",·version)); |
| 158 | » » » return·null; | 172 | » » » » return·null; |
| 173 | » » » } | ||
| 174 | » » » return·NormalGameOptionsV08.Deserialize(reader,·isAprilFoolsMode,·this.logger); | ||
| 159 | » » } | 175 | » » } |
| 160 | 176 | ||
| 161 | » » private·IGameOptions·HideNSeekModeFromBytes(MessageReader·reader,·byte·version,·bool·isAprilFoolsMode) | 177 | » » private·IGameOptions·HideNSeekModeFromBytes(MessageReader·reader,·byte·version,·bool·isAprilFoolsMode) |
| 162 | » » { | 178 | » » { |
| 163 | » » » if·(version·==·7) | 179 | » » » if·(version·==·7) |
| 164 | » » » { | 180 | » » » { |
| 165 | » » » » return·HideNSeekGameOptionsV07.Deserialize(reader,·isAprilFoolsMode,·this.logger); | 181 | » » » » return·HideNSeekGameOptionsV07.Deserialize(reader,·isAprilFoolsMode,·this.logger); |
| 166 | » » » } | 182 | » » » } |
| 183 | » » » if·(version·!=·8) | ||
| 184 | » » » { | ||
| 167 | » » » this.logger.WriteError(string.Format("Could·not·parse·hidenseek·game·options·for·version·{0}",·version)); | 185 | » » » » this.logger.WriteError(string.Format("Could·not·parse·hidenseek·game·options·for·version·{0}",·version)); |
| 168 | » » » return·null; | 186 | » » » » return·null; |
| 187 | » » » } | ||
| 188 | » » » return·HideNSeekGameOptionsV08.Deserialize(reader,·isAprilFoolsMode,·this.logger); | ||
| 169 | » » } | 189 | » » } |
| 170 | 190 | ||
| 171 | » » private·const·byte·ModularOptionsDataVersion·=·7; | 191 | » » private·const·byte·ModularOptionsDataVersion·=·7; |
| 172 | 192 | ||
| 173 | » » private·readonly·ILogger·logger; | 193 | » » private·readonly·ILogger·logger; |
| 174 | » } | 194 | » } |
| 175 | } | 195 | } |
| Offset 11, 14 lines modified | Offset 11, 22 lines modified | ||
| 11 | » » » { | 11 | » » » { |
| 12 | » » » » return·7; | 12 | » » » » return·7; |
| 13 | » » » } | 13 | » » » } |
| 14 | » » } | 14 | » » } |
| 15 | 15 | ||
| 16 | » » public·GameModes·GameMode·{·get;·private·set;·}·=·GameModes.HideNSeek; | 16 | » » public·GameModes·GameMode·{·get;·private·set;·}·=·GameModes.HideNSeek; |
| 17 | 17 | ||
| 18 | » » public·SpecialGameModes·SpecialMode | ||
| 19 | » » { | ||
| 20 | » » » get | ||
| 21 | » » » { | ||
| 22 | » » » » return·SpecialGameModes.None; | ||
| 23 | » » » } | ||
| 24 | » » } | ||
| 25 | |||
| 18 | » » public·GameModes·AprilFoolsOnMode | 26 | » » public·GameModes·AprilFoolsOnMode |
| 19 | » » { | 27 | » » { |
| 20 | » » » get | 28 | » » » get |
| 21 | » » » { | 29 | » » » { |
| 22 | » » » » return·GameModes.SeekFools; | 30 | » » » » return·GameModes.SeekFools; |
| 23 | » » » } | 31 | » » » } |
| 24 | » » } | 32 | » » } |
| Offset 27, 14 lines modified | Offset 35, 16 lines modified | ||
| 27 | » » { | 35 | » » { |
| 28 | » » » get | 36 | » » » get |
| 29 | » » » { | 37 | » » » { |
| 30 | » » » » return·GameModes.HideNSeek; | 38 | » » » » return·GameModes.HideNSeek; |
| 31 | » » » } | 39 | » » » } |
| 32 | » » } | 40 | » » } |
| 33 | 41 | ||
| 42 | » » public·RulesPresets·RulesPreset·{·get;·set;·} | ||
| 43 | |||
| 34 | » » public·int·MaxPlayers·{·get;·private·set;·}·=·15; | 44 | » » public·int·MaxPlayers·{·get;·private·set;·}·=·15; |
| 35 | 45 | ||
| 36 | » » public·GameKeywords·Keywords·{·get;·private·set;·}·=·GameKeywords.English; | 46 | » » public·GameKeywords·Keywords·{·get;·private·set;·}·=·GameKeywords.English; |
| 37 | 47 | ||
| 38 | » » public·byte·MapId·{·get;·private·set;·} | 48 | » » public·byte·MapId·{·get;·private·set;·} |
| 39 | 49 | ||
| 40 | » » public·bool·IsDefaults·{·get;·private·set;·}·=·true; | 50 | » » public·bool·IsDefaults·{·get;·private·set;·}·=·true; |
| Offset 154, 14 lines modified | Offset 164, 18 lines modified | ||
| 154 | » » » this.SeekerFinalSpeed·=·1.2f; | 164 | » » » this.SeekerFinalSpeed·=·1.2f; |
| 155 | » » » this.SeekerPings·=·true; | 165 | » » » this.SeekerPings·=·true; |
| 156 | » » » this.ShowCrewmateNames·=·false; | 166 | » » » this.ShowCrewmateNames·=·false; |
| 157 | » » » this.MaxPingTime·=·6f; | 167 | » » » this.MaxPingTime·=·6f; |
| 158 | » » » this.IsDefaults·=·true; | 168 | » » » this.IsDefaults·=·true; |
| 159 | » » } | 169 | » » } |
| 160 | 170 | ||
| 171 | » » public·void·SetRecommendations(int·numPlayers,·bool·isOnline,·RulesPresets·rulesPresets) | ||
| 172 | » » { | ||
| 173 | » » } | ||
| 174 | |||
| 161 | » » public·void·SetByte(ByteOptionNames·optionName,·byte·value) | 175 | » » public·void·SetByte(ByteOptionNames·optionName,·byte·value) |
| 162 | » » { | 176 | » » { |
| 163 | » » » if·(optionName·==·ByteOptionNames.MapId) | 177 | » » » if·(optionName·==·ByteOptionNames.MapId) |
| 164 | » » » { | 178 | » » » { |
| 165 | » » » » this.MapId·=·value; | 179 | » » » » this.MapId·=·value; |
| 166 | » » » » return; | 180 | » » » » return; |
| 167 | » » » } | 181 | » » » } |
| Offset 4, 18 lines modified | Offset 4, 22 lines modified | ||
| 4 | { | 4 | { |
| 5 | » public·interface·IGameOptions | 5 | » public·interface·IGameOptions |
| 6 | » { | 6 | » { |
| 7 | » » byte·Version·{·get;·} | 7 | » » byte·Version·{·get;·} |
| 8 | 8 | ||
| 9 | » » GameModes·GameMode·{·get;·} | 9 | » » GameModes·GameMode·{·get;·} |
| 10 | 10 | ||
| 11 | » » SpecialGameModes·SpecialMode·{·get;·} | ||
| 12 | |||
| 11 | » » GameModes·AprilFoolsOnMode·{·get;·} | 13 | » » GameModes·AprilFoolsOnMode·{·get;·} |
| 12 | 14 | ||
| 13 | » » GameModes·AprilFoolsOffMode·{·get;·} | 15 | » » GameModes·AprilFoolsOffMode·{·get;·} |
| 14 | 16 | ||
| 17 | » » RulesPresets·RulesPreset·{·get;·} | ||
| 18 | |||
| 15 | » » int·MaxPlayers·{·get;·} | 19 | » » int·MaxPlayers·{·get;·} |
| 16 | 20 | ||
| 17 | » » GameKeywords·Keywords·{·get;·} | 21 | » » GameKeywords·Keywords·{·get;·} |
| 18 | 22 | ||
| 19 | » » byte·MapId·{·get;·} | 23 | » » byte·MapId·{·get;·} |
| 20 | 24 | ||
| 21 | » » int·NumImpostors·{·get;·} | 25 | » » int·NumImpostors·{·get;·} |
| Offset 26, 14 lines modified | Offset 30, 16 lines modified | ||
| 26 | 30 | ||
| 27 | » » IRoleOptionsCollection·RoleOptions·{·get;·} | 31 | » » IRoleOptionsCollection·RoleOptions·{·get;·} |
| 28 | 32 | ||
| 29 | » » bool·AreInvalid(int·maxExpectedPlayers); | 33 | » » bool·AreInvalid(int·maxExpectedPlayers); |
| 30 | 34 | ||
| 31 | » » void·SetRecommendations(int·numPlayers,·bool·isOnlineGame); | 35 | » » void·SetRecommendations(int·numPlayers,·bool·isOnlineGame); |
| 32 | 36 | ||
| 37 | » » void·SetRecommendations(int·numPlayers,·bool·isOnlineGame,·RulesPresets·rulesPreset); | ||
| 38 | |||
| 33 | » » void·SetByte(ByteOptionNames·optionName,·byte·value); | 39 | » » void·SetByte(ByteOptionNames·optionName,·byte·value); |
| 34 | 40 | ||
| 35 | » » void·SetFloat(FloatOptionNames·optionName,·float·value); | 41 | » » void·SetFloat(FloatOptionNames·optionName,·float·value); |
| 36 | 42 | ||
| 37 | » » void·SetBool(BoolOptionNames·optionName,·bool·value); | 43 | » » void·SetBool(BoolOptionNames·optionName,·bool·value); |
| 38 | 44 | ||
| 39 | » » void·SetInt(Int32OptionNames·optionName,·int·value); | 45 | » » void·SetInt(Int32OptionNames·optionName,·int·value); |
| Offset 16, 10 lines modified | Offset 16, 11 lines modified | ||
| 16 | » » MaxPlayers, | 16 | » » MaxPlayers, |
| 17 | » » NumCommonTasks, | 17 | » » NumCommonTasks, |
| 18 | » » NumShortTasks, | 18 | » » NumShortTasks, |
| 19 | » » NumLongTasks, | 19 | » » NumLongTasks, |
| 20 | » » TaskBarMode, | 20 | » » TaskBarMode, |
| 21 | » » CrewmatesRemainingForVitals·=·100, | 21 | » » CrewmatesRemainingForVitals·=·100, |
| 22 | » » CrewmateVentUses, | 22 | » » CrewmateVentUses, |
| 23 | » » ImpostorPlayerID | 23 | » » ImpostorPlayerID, |
| 24 | » » RulePreset·=·200 | ||
| 24 | » } | 25 | » } |
| 25 | } | 26 | } |
| Offset 11, 14 lines modified | Offset 11, 22 lines modified | ||
| 11 | » » » { | 11 | » » » { |
| 12 | » » » » return·7; | 12 | » » » » return·7; |
| 13 | » » » } | 13 | » » » } |
| 14 | » » } | 14 | » » } |
| 15 | 15 | ||
| 16 | » » public·GameModes·GameMode·{·get;·private·set;·}·=·GameModes.Normal; | 16 | » » public·GameModes·GameMode·{·get;·private·set;·}·=·GameModes.Normal; |
| 17 | 17 | ||
| 18 | » » public·SpecialGameModes·SpecialMode | ||
| 19 | » » { | ||
| 20 | » » » get | ||
| 21 | » » » { | ||
| 22 | » » » » return·SpecialGameModes.None; | ||
| 23 | » » » } | ||
| 24 | » » } | ||
| 25 | |||
| 18 | » » public·GameModes·AprilFoolsOnMode | 26 | » » public·GameModes·AprilFoolsOnMode |
| 19 | » » { | 27 | » » { |
| 20 | » » » get | 28 | » » » get |
| 21 | » » » { | 29 | » » » { |
| 22 | » » » » return·GameModes.NormalFools; | 30 | » » » » return·GameModes.NormalFools; |
| 23 | » » » } | 31 | » » » } |
| 24 | » » } | 32 | » » } |
| Offset 27, 14 lines modified | Offset 35, 16 lines modified | ||
| 27 | » » { | 35 | » » { |
| 28 | » » » get | 36 | » » » get |
| 29 | » » » { | 37 | » » » { |
| 30 | » » » » return·GameModes.Normal; | 38 | » » » » return·GameModes.Normal; |
| 31 | » » » } | 39 | » » » } |
| 32 | » » } | 40 | » » } |
| 33 | 41 | ||
| 42 | » » public·RulesPresets·RulesPreset·{·get;·set;·} | ||
| 43 | |||
| 34 | » » public·int·MaxPlayers·{·get;·set;·}·=·10; | 44 | » » public·int·MaxPlayers·{·get;·set;·}·=·10; |
| 35 | 45 | ||
| 36 | » » public·GameKeywords·Keywords·{·get;·set;·}·=·GameKeywords.English; | 46 | » » public·GameKeywords·Keywords·{·get;·set;·}·=·GameKeywords.English; |
| 37 | 47 | ||
| 38 | » » public·byte·MapId·{·get;·set;·} | 48 | » » public·byte·MapId·{·get;·set;·} |
| 39 | 49 | ||
| 40 | » » public·bool·IsDefaults·{·get;·set;·}·=·true; | 50 | » » public·bool·IsDefaults·{·get;·set;·}·=·true; |
| Offset 163, 14 lines modified | Offset 173, 18 lines modified | ||
| 163 | » » » this.roleOptions.SetRoleRate(RoleTypes.Engineer,·0,·0); | 173 | » » » this.roleOptions.SetRoleRate(RoleTypes.Engineer,·0,·0); |
| 164 | » » » this.roleOptions.SetRoleRecommended(RoleTypes.Shapeshifter); | 174 | » » » this.roleOptions.SetRoleRecommended(RoleTypes.Shapeshifter); |
| 165 | » » » this.roleOptions.SetRoleRecommended(RoleTypes.Scientist); | 175 | » » » this.roleOptions.SetRoleRecommended(RoleTypes.Scientist); |
| 166 | » » » this.roleOptions.SetRoleRecommended(RoleTypes.GuardianAngel); | 176 | » » » this.roleOptions.SetRoleRecommended(RoleTypes.GuardianAngel); |
| 167 | » » » this.roleOptions.SetRoleRecommended(RoleTypes.Engineer); | 177 | » » » this.roleOptions.SetRoleRecommended(RoleTypes.Engineer); |
| 168 | » » } | 178 | » » } |
| 169 | 179 | ||
| 180 | » » public·void·SetRecommendations(int·numPlayers,·bool·isOnline,·RulesPresets·rulesPresets) | ||
| 181 | » » { | ||
| 182 | » » } | ||
| 183 | |||
| 170 | » » public·void·SetByte(ByteOptionNames·optionName,·byte·value) | 184 | » » public·void·SetByte(ByteOptionNames·optionName,·byte·value) |
| 171 | » » { | 185 | » » { |
| 172 | » » » if·(optionName·==·ByteOptionNames.MapId) | 186 | » » » if·(optionName·==·ByteOptionNames.MapId) |
| 173 | » » » { | 187 | » » » { |
| 174 | » » » » this.MapId·=·value; | 188 | » » » » this.MapId·=·value; |
| 175 | » » » » return; | 189 | » » » » return; |
| 176 | » » » } | 190 | » » » } |
| Offset 7, 10 lines modified | Offset 7, 13 lines modified | ||
| 7 | » » Crewmate, | 7 | » » Crewmate, |
| 8 | » » Impostor, | 8 | » » Impostor, |
| 9 | » » Scientist, | 9 | » » Scientist, |
| 10 | » » Engineer, | 10 | » » Engineer, |
| 11 | » » GuardianAngel, | 11 | » » GuardianAngel, |
| 12 | » » Shapeshifter, | 12 | » » Shapeshifter, |
| 13 | » » CrewmateGhost, | 13 | » » CrewmateGhost, |
| 14 | » » ImpostorGhost | 14 | » » ImpostorGhost, |
| 15 | » » Noisemaker, | ||
| 16 | » » Phantom, | ||
| 17 | » » Tracker | ||
| 15 | » } | 18 | » } |
| 16 | } | 19 | } |
| Offset 195, 16 lines modified | Offset 195, 16 lines modified | ||
| 195 | » » [SerializeField] | 195 | » » [SerializeField] |
| 196 | » » [Space(10f)] | 196 | » » [Space(10f)] |
| 197 | » » private·TextMeshPro·text; | 197 | » » private·TextMeshPro·text; |
| 198 | 198 | ||
| 199 | » » [SerializeField] | 199 | » » [SerializeField] |
| 200 | » » private·RectTransform·textRect; | 200 | » » private·RectTransform·textRect; |
| 201 | 201 | ||
| 202 | » » [Space(10f)] | ||
| 203 | » » [SerializeField] | 202 | » » [SerializeField] |
| 203 | » » [Space(10f)] | ||
| 204 | » » private·SpriteRenderer·arrow; | 204 | » » private·SpriteRenderer·arrow; |
| 205 | 205 | ||
| 206 | » » [SerializeField] | 206 | » » [SerializeField] |
| 207 | » » private·SpriteRenderer[]·backgroundSprites; | 207 | » » private·SpriteRenderer[]·backgroundSprites; |
| 208 | 208 | ||
| 209 | » » private·QuickChatPhrase·phrase; | 209 | » » private·QuickChatPhrase·phrase; |
| 210 | 210 | ||
| Offset 159, 15 lines modified | Offset 159, 15 lines modified | ||
| 159 | » » } | 159 | » » } |
| 160 | 160 | ||
| 161 | » » private·void·UpdateWithCurrentMap() | 161 | » » private·void·UpdateWithCurrentMap() |
| 162 | » » { | 162 | » » { |
| 163 | » » » ShipStatus·instance·=·ShipStatus.Instance; | 163 | » » » ShipStatus·instance·=·ShipStatus.Instance; |
| 164 | » » » this.phase·=·QuickChatContextPhase.Game; | 164 | » » » this.phase·=·QuickChatContextPhase.Game; |
| 165 | » » » this.map·=·this.GetCurrentMapID(instance); | 165 | » » » this.map·=·this.GetCurrentMapID(instance); |
| 166 | » » » this.meetingCount·=· | 166 | » » » this.meetingCount·=·GameData.MeetingCount; |
| 167 | » » » this.locations·=·Enumerable.ToArray<StringNames>(Enumerable.Distinct<StringNames>(Enumerable.Select<PlainShipRoom,·StringNames>(instance.AllRooms,·(PlainShipRoom·room)·=>·DestroyableSingleton<TranslationController>.Instance.GetSystemName(room.RoomId)))); | 167 | » » » this.locations·=·Enumerable.ToArray<StringNames>(Enumerable.Distinct<StringNames>(Enumerable.Select<PlainShipRoom,·StringNames>(instance.AllRooms,·(PlainShipRoom·room)·=>·DestroyableSingleton<TranslationController>.Instance.GetSystemName(room.RoomId)))); |
| 168 | » » » this.roles·=·Enumerable.ToArray<StringNames>(Enumerable.Distinct<StringNames>(Enumerable.Concat<StringNames>(Enumerable.Select<RoleBehaviour,·StringNames>(Enumerable.Where<RoleBehaviour>(DestroyableSingleton<RoleManager>.Instance.AllRoles,·(RoleBehaviour·role)·=>·!Enumerable.Contains<RoleTypes>(QuickChatContext.ROLES_TO_IGNORE,·role.Role)),·(RoleBehaviour·role)·=>·role.StringName),·new·StringNames[]·{·StringNames.Ghost·}))); | 168 | » » » this.roles·=·Enumerable.ToArray<StringNames>(Enumerable.Distinct<StringNames>(Enumerable.Concat<StringNames>(Enumerable.Select<RoleBehaviour,·StringNames>(Enumerable.Where<RoleBehaviour>(DestroyableSingleton<RoleManager>.Instance.AllRoles,·(RoleBehaviour·role)·=>·!Enumerable.Contains<RoleTypes>(QuickChatContext.ROLES_TO_IGNORE,·role.Role)),·(RoleBehaviour·role)·=>·role.StringName),·new·StringNames[]·{·StringNames.Ghost·}))); |
| 169 | » » » this.systems·=·instance.SystemNames; | 169 | » » » this.systems·=·instance.SystemNames; |
| 170 | » » » this.tasks·=·Enumerable.ToArray<StringNames>(Enumerable.Distinct<StringNames>(Enumerable.Where<StringNames>(Enumerable.Concat<StringNames>(instance.ExtraTaskNames,·Enumerable.Select<PlayerTask,·StringNames>(instance.GetAllTasks(),·(PlayerTask·task)·=>·DestroyableSingleton<TranslationController>.Instance.GetTaskName(task.TaskType))),·(StringNames·stringName)·=>·!Enumerable.Contains<StringNames>(QuickChatContext.TASKS_TO_IGNORE,·stringName)))); | 170 | » » » this.tasks·=·Enumerable.ToArray<StringNames>(Enumerable.Distinct<StringNames>(Enumerable.Where<StringNames>(Enumerable.Concat<StringNames>(instance.ExtraTaskNames,·Enumerable.Select<PlayerTask,·StringNames>(instance.GetAllTasks(),·(PlayerTask·task)·=>·DestroyableSingleton<TranslationController>.Instance.GetTaskName(task.TaskType))),·(StringNames·stringName)·=>·!Enumerable.Contains<StringNames>(QuickChatContext.TASKS_TO_IGNORE,·stringName)))); |
| 171 | » » } | 171 | » » } |
| 172 | 172 | ||
| 173 | » » private·MapNames·GetCurrentMapID(ShipStatus·ship) | 173 | » » private·MapNames·GetCurrentMapID(ShipStatus·ship) |
| Offset 418, 30 lines modified | Offset 418, 30 lines modified | ||
| 418 | 418 | ||
| 419 | » » [SerializeField] | 419 | » » [SerializeField] |
| 420 | » » private·Transform·container; | 420 | » » private·Transform·container; |
| 421 | 421 | ||
| 422 | » » [SerializeField] | 422 | » » [SerializeField] |
| 423 | » » private·SpriteRenderer·frame; | 423 | » » private·SpriteRenderer·frame; |
| 424 | 424 | ||
| 425 | » » [SerializeField] | ||
| 426 | » » [Space(10f)] | 425 | » » [Space(10f)] |
| 426 | » » [SerializeField] | ||
| 427 | » » private·Transform·topContentBlocker; | 427 | » » private·Transform·topContentBlocker; |
| 428 | 428 | ||
| 429 | » » [SerializeField] | 429 | » » [SerializeField] |
| 430 | » » private·Transform·bottomContentBlocker; | 430 | » » private·Transform·bottomContentBlocker; |
| 431 | 431 | ||
| 432 | » » [Space(10f)] | 432 | » » [Space(10f)] |
| 433 | » » [SerializeField] | 433 | » » [SerializeField] |
| 434 | » » private·PassiveButton·closeButton; | 434 | » » private·PassiveButton·closeButton; |
| 435 | 435 | ||
| 436 | » » [SerializeField] | 436 | » » [SerializeField] |
| 437 | » » private·GameObject·closeButtonGlyph; | 437 | » » private·GameObject·closeButtonGlyph; |
| 438 | 438 | ||
| 439 | » » [Header("Animations")] | ||
| 440 | » » [SerializeField] | 439 | » » [SerializeField] |
| 440 | » » [Header("Animations")] | ||
| 441 | » » private·AnimationCurve·animationIn; | 441 | » » private·AnimationCurve·animationIn; |
| 442 | 442 | ||
| 443 | » » [SerializeField] | 443 | » » [SerializeField] |
| 444 | » » private·AnimationCurve·animationOut; | 444 | » » private·AnimationCurve·animationOut; |
| 445 | 445 | ||
| 446 | » » [Header("Pages")] | 446 | » » [Header("Pages")] |
| 447 | » » [SerializeField] | 447 | » » [SerializeField] |
| Offset 179, 27 lines modified | Offset 179, 27 lines modified | ||
| 179 | 179 | ||
| 180 | » » [SerializeField] | 180 | » » [SerializeField] |
| 181 | » » private·Transform·textMask; | 181 | » » private·Transform·textMask; |
| 182 | 182 | ||
| 183 | » » [SerializeField] | 183 | » » [SerializeField] |
| 184 | » » private·Transform·textGradient; | 184 | » » private·Transform·textGradient; |
| 185 | 185 | ||
| 186 | » » [Space(10f)] | ||
| 187 | » » [SerializeField] | 186 | » » [SerializeField] |
| 187 | » » [Space(10f)] | ||
| 188 | » » private·PassiveButton·backButton; | 188 | » » private·PassiveButton·backButton; |
| 189 | 189 | ||
| 190 | » » [SerializeField] | 190 | » » [SerializeField] |
| 191 | » » private·BoxCollider2D·backButtonCollider; | 191 | » » private·BoxCollider2D·backButtonCollider; |
| 192 | 192 | ||
| 193 | » » [SerializeField] | ||
| 194 | » » [Space(10f)] | 193 | » » [Space(10f)] |
| 194 | » » [SerializeField] | ||
| 195 | » » private·Transform·divider; | 195 | » » private·Transform·divider; |
| 196 | 196 | ||
| 197 | » » [SerializeField] | ||
| 198 | » » [Space(10f)] | 197 | » » [Space(10f)] |
| 198 | » » [SerializeField] | ||
| 199 | » » private·GameObject·favoriteBox; | 199 | » » private·GameObject·favoriteBox; |
| 200 | 200 | ||
| 201 | » » [SerializeField] | 201 | » » [SerializeField] |
| 202 | » » private·GameObject·favoriteBoxContainer; | 202 | » » private·GameObject·favoriteBoxContainer; |
| 203 | 203 | ||
| 204 | » » [SerializeField] | 204 | » » [SerializeField] |
| 205 | » » private·GameObject·favoriteBoxGlyph; | 205 | » » private·GameObject·favoriteBoxGlyph; |
| Offset 175, 16 lines modified | Offset 175, 16 lines modified | ||
| 175 | 175 | ||
| 176 | » » [SerializeField] | 176 | » » [SerializeField] |
| 177 | » » private·QuickChatMenuLandingPageButton·remarksButton; | 177 | » » private·QuickChatMenuLandingPageButton·remarksButton; |
| 178 | 178 | ||
| 179 | » » [SerializeField] | 179 | » » [SerializeField] |
| 180 | » » private·Transform·contentBlocker; | 180 | » » private·Transform·contentBlocker; |
| 181 | 181 | ||
| 182 | » » [Header("List")] | ||
| 183 | » » [SerializeField] | 182 | » » [SerializeField] |
| 183 | » » [Header("List")] | ||
| 184 | » » private·Transform·listContainer; | 184 | » » private·Transform·listContainer; |
| 185 | 185 | ||
| 186 | » » [SerializeField] | 186 | » » [SerializeField] |
| 187 | » » private·QuickChatMenuScroller·scroller; | 187 | » » private·QuickChatMenuScroller·scroller; |
| 188 | 188 | ||
| 189 | » » [SerializeField] | 189 | » » [SerializeField] |
| 190 | » » private·QuickChatMenuLandingPageButton·buttonTemplate; | 190 | » » private·QuickChatMenuLandingPageButton·buttonTemplate; |
| Offset 132, 16 lines modified | Offset 132, 16 lines modified | ||
| 132 | 132 | ||
| 133 | » » [SerializeField] | 133 | » » [SerializeField] |
| 134 | » » private·RectTransform·textRect; | 134 | » » private·RectTransform·textRect; |
| 135 | 135 | ||
| 136 | » » [SerializeField] | 136 | » » [SerializeField] |
| 137 | » » private·TextTranslatorTMP·translator; | 137 | » » private·TextTranslatorTMP·translator; |
| 138 | 138 | ||
| 139 | » » [SerializeField] | ||
| 140 | » » [Space(10f)] | 139 | » » [Space(10f)] |
| 140 | » » [SerializeField] | ||
| 141 | » » private·SpriteRenderer[]·backgroundSprites; | 141 | » » private·SpriteRenderer[]·backgroundSprites; |
| 142 | 142 | ||
| 143 | » » [SerializeField] | 143 | » » [SerializeField] |
| 144 | » » private·SpriteRenderer[]·shineSprites; | 144 | » » private·SpriteRenderer[]·shineSprites; |
| 145 | 145 | ||
| 146 | » » private·new·QuickChatTag·tag; | 146 | » » private·new·QuickChatTag·tag; |
| 147 | » } | 147 | » } |
| Offset 181, 20 lines modified | Offset 181, 20 lines modified | ||
| 181 | 181 | ||
| 182 | » » private·const·float·BOTTOM_PADDING·=·0.1f; | 182 | » » private·const·float·BOTTOM_PADDING·=·0.1f; |
| 183 | 183 | ||
| 184 | » » private·static·readonly·Color32·TEXT_COLOR_ENABLED·=·Color.white; | 184 | » » private·static·readonly·Color32·TEXT_COLOR_ENABLED·=·Color.white; |
| 185 | 185 | ||
| 186 | » » private·static·readonly·Color32·TEXT_COLOR_DISABLED·=·new·Color32(123,·123,·123,·byte.MaxValue); | 186 | » » private·static·readonly·Color32·TEXT_COLOR_DISABLED·=·new·Color32(123,·123,·123,·byte.MaxValue); |
| 187 | 187 | ||
| 188 | » » [Header("UI")] | ||
| 189 | » » [SerializeField] | 188 | » » [SerializeField] |
| 189 | » » [Header("UI")] | ||
| 190 | » » private·QuickChatMenuScroller·scroller; | 190 | » » private·QuickChatMenuScroller·scroller; |
| 191 | 191 | ||
| 192 | » » [Header("Button·Templates")] | ||
| 193 | » » [SerializeField] | 192 | » » [SerializeField] |
| 193 | » » [Header("Button·Templates")] | ||
| 194 | » » private·QuickChatMenuPhrasesPagePhraseButton·phraseButtonTemplate; | 194 | » » private·QuickChatMenuPhrasesPagePhraseButton·phraseButtonTemplate; |
| 195 | 195 | ||
| 196 | » » [SerializeField] | 196 | » » [SerializeField] |
| 197 | » » private·QuickChatMenuPhrasesPageCrewmateButton·crewmateButtonTemplate; | 197 | » » private·QuickChatMenuPhrasesPageCrewmateButton·crewmateButtonTemplate; |
| 198 | 198 | ||
| 199 | » » [SerializeField] | 199 | » » [SerializeField] |
| 200 | » » private·Material·defaultButtonTextMaterial; | 200 | » » private·Material·defaultButtonTextMaterial; |
| Offset 34, 15 lines modified | Offset 34, 15 lines modified | ||
| 34 | » » » base.TextRect.sizeDelta·=·base.Collider.size; | 34 | » » » base.TextRect.sizeDelta·=·base.Collider.size; |
| 35 | » » » Vector3·localPosition·=·base.TextRect.localPosition; | 35 | » » » Vector3·localPosition·=·base.TextRect.localPosition; |
| 36 | » » » localPosition.x·=·base.Collider.offset.x; | 36 | » » » localPosition.x·=·base.Collider.offset.x; |
| 37 | » » » localPosition.y·=·base.Collider.offset.y; | 37 | » » » localPosition.y·=·base.Collider.offset.y; |
| 38 | » » » base.TextRect.localPosition·=·localPosition; | 38 | » » » base.TextRect.localPosition·=·localPosition; |
| 39 | » » » this.playerMask.material·=·new·Material(this.playerMask.material); | 39 | » » » this.playerMask.material·=·new·Material(this.playerMask.material); |
| 40 | » » » this.playerMask.material.SetInt(PlayerMaterial.MaskLayer,·base.MaskLayer); | 40 | » » » this.playerMask.material.SetInt(PlayerMaterial.MaskLayer,·base.MaskLayer); |
| 41 | » » » | 41 | » » » NetworkedPlayerInfo·data·=·Enumerable.First<PlayerControl>(Enumerable.Where<PlayerControl>(PlayerControl.AllPlayerControls,·(PlayerControl·p)·=>·p.PlayerId·==·base.Phrase.PlayerId)).Data; |
| 42 | » » » this.player.UpdateFromEitherPlayerDataOrCache(data,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ComplexUI,·false,·null); | 42 | » » » this.player.UpdateFromEitherPlayerDataOrCache(data,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ComplexUI,·false,·null); |
| 43 | » » » this.player.SetHatAndVisorMaskType(PlayerMaterial.MaskType.None); | 43 | » » » this.player.SetHatAndVisorMaskType(PlayerMaterial.MaskType.None); |
| 44 | » » » base.StartCoroutine(this.CoSetPlayerRendererIndexes()); | 44 | » » » base.StartCoroutine(this.CoSetPlayerRendererIndexes()); |
| 45 | » » » this.playerColorBackgrounds.ForEach(delegate(SpriteRenderer·x) | 45 | » » » this.playerColorBackgrounds.ForEach(delegate(SpriteRenderer·x) |
| 46 | » » » { | 46 | » » » { |
| 47 | » » » » x.color·=·base.Phrase.ToPlayerBackgroundColor(); | 47 | » » » » x.color·=·base.Phrase.ToPlayerBackgroundColor(); |
| 48 | » » » }); | 48 | » » » }); |
| Offset 87, 12 lines modified | Offset 87, 12 lines modified | ||
| 87 | » » } | 87 | » » } |
| 88 | 88 | ||
| 89 | » » private·void·OnFavoritePressed() | 89 | » » private·void·OnFavoritePressed() |
| 90 | » » { | 90 | » » { |
| 91 | » » » this.ToggleFavorite(); | 91 | » » » this.ToggleFavorite(); |
| 92 | » » } | 92 | » » } |
| 93 | 93 | ||
| 94 | » » [Header("Phrase·Button")] | ||
| 95 | » » [SerializeField] | 94 | » » [SerializeField] |
| 95 | » » [Header("Phrase·Button")] | ||
| 96 | » » private·QuickChatFavoriteIcon·favoriteIcon; | 96 | » » private·QuickChatFavoriteIcon·favoriteIcon; |
| 97 | » } | 97 | » } |
| 98 | } | 98 | } |
| Offset 127, 23 lines modified | Offset 127, 23 lines modified | ||
| 127 | 127 | ||
| 128 | » » [SerializeField] | 128 | » » [SerializeField] |
| 129 | » » private·BoxCollider2D·collider; | 129 | » » private·BoxCollider2D·collider; |
| 130 | 130 | ||
| 131 | » » [SerializeField] | 131 | » » [SerializeField] |
| 132 | » » private·ScrollToSelection·scrollToSelection; | 132 | » » private·ScrollToSelection·scrollToSelection; |
| 133 | 133 | ||
| 134 | » » [Header("Gradients")] | ||
| 135 | » » [SerializeField] | 134 | » » [SerializeField] |
| 135 | » » [Header("Gradients")] | ||
| 136 | » » private·SpriteRenderer·topGradient; | 136 | » » private·SpriteRenderer·topGradient; |
| 137 | 137 | ||
| 138 | » » [SerializeField] | 138 | » » [SerializeField] |
| 139 | » » private·Transform·topGradientContainer; | 139 | » » private·Transform·topGradientContainer; |
| 140 | 140 | ||
| 141 | » » [Space(10f)] | ||
| 142 | » » [SerializeField] | 141 | » » [SerializeField] |
| 142 | » » [Space(10f)] | ||
| 143 | » » private·SpriteRenderer·bottomGradient; | 143 | » » private·SpriteRenderer·bottomGradient; |
| 144 | 144 | ||
| 145 | » » [SerializeField] | 145 | » » [SerializeField] |
| 146 | » » private·Transform·bottomGradientContainer; | 146 | » » private·Transform·bottomGradientContainer; |
| 147 | 147 | ||
| 148 | » » private·float·width; | 148 | » » private·float·width; |
| 149 | 149 | ||
| Offset 178, 15 lines modified | Offset 178, 15 lines modified | ||
| 178 | » » private·string·ToPlayerNameText(bool·boldPlayerName) | 178 | » » private·string·ToPlayerNameText(bool·boldPlayerName) |
| 179 | » » { | 179 | » » { |
| 180 | » » » if·(this.PlayerId·==·255) | 180 | » » » if·(this.PlayerId·==·255) |
| 181 | » » » { | 181 | » » » { |
| 182 | » » » » QuickChatMenu.Logger.Error("[QuickChatPhrase]·ToPlayerNameText()·::·'playerId'·was·empty·or·uninitialized.·Returning·null·string.",·null); | 182 | » » » » QuickChatMenu.Logger.Error("[QuickChatPhrase]·ToPlayerNameText()·::·'playerId'·was·empty·or·uninitialized.·Returning·null·string.",·null); |
| 183 | » » » » return·null; | 183 | » » » » return·null; |
| 184 | » » » } | 184 | » » » } |
| 185 | » » » | 185 | » » » NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(this.PlayerId); |
| 186 | » » » if·(!boldPlayerName) | 186 | » » » if·(!boldPlayerName) |
| 187 | » » » { | 187 | » » » { |
| 188 | » » » » return·playerById.PlayerName; | 188 | » » » » return·playerById.PlayerName; |
| 189 | » » » } | 189 | » » » } |
| 190 | » » » return·QuickChatPhrase.AddBoldTagsIfSupported(playerById.PlayerName); | 190 | » » » return·QuickChatPhrase.AddBoldTagsIfSupported(playerById.PlayerName); |
| 191 | » » } | 191 | » » } |
| 192 | 192 | ||
| Offset 104, 43 lines modified | Offset 104, 43 lines modified | ||
| 104 | » » » » » } | 104 | » » » » » } |
| 105 | » » » » » this.cachedPhrase·=·QuickChatPhrase.NewComplexPhrase(this.key,·array,·this.isNegative); | 105 | » » » » » this.cachedPhrase·=·QuickChatPhrase.NewComplexPhrase(this.key,·array,·this.isNegative); |
| 106 | » » » » } | 106 | » » » » } |
| 107 | » » » } | 107 | » » » } |
| 108 | » » » return·this.cachedPhrase; | 108 | » » » return·this.cachedPhrase; |
| 109 | » » } | 109 | » » } |
| 110 | 110 | ||
| 111 | » » [Header("Phrase·Properties")] | ||
| 112 | » » [SerializeField] | 111 | » » [SerializeField] |
| 112 | » » [Header("Phrase·Properties")] | ||
| 113 | » » private·string·text; | 113 | » » private·string·text; |
| 114 | 114 | ||
| 115 | » » [SerializeField] | 115 | » » [SerializeField] |
| 116 | » » private·StringNames·key; | 116 | » » private·StringNames·key; |
| 117 | 117 | ||
| 118 | » » [SerializeField] | 118 | » » [SerializeField] |
| 119 | » » private·Sprite·icon; | 119 | » » private·Sprite·icon; |
| 120 | 120 | ||
| 121 | » » [SerializeField] | 121 | » » [SerializeField] |
| 122 | » » private·int·order; | 122 | » » private·int·order; |
| 123 | 123 | ||
| 124 | » » [SerializeField] | ||
| 125 | » » [Header("Usage")] | 124 | » » [Header("Usage")] |
| 125 | » » [SerializeField] | ||
| 126 | » » private·bool·isInput; | 126 | » » private·bool·isInput; |
| 127 | 127 | ||
| 128 | » » [SerializeField] | 128 | » » [SerializeField] |
| 129 | » » private·bool·isNegative; | 129 | » » private·bool·isNegative; |
| 130 | 130 | ||
| 131 | » » [Space(10f)] | 131 | » » [Space(10f)] |
| 132 | » » [SerializeField] | 132 | » » [SerializeField] |
| 133 | » » private·QuickChatTag[]·tags; | 133 | » » private·QuickChatTag[]·tags; |
| 134 | 134 | ||
| 135 | » » [SerializeField] | 135 | » » [SerializeField] |
| 136 | » » private·QuickChatPhraseInput[]·inputs; | 136 | » » private·QuickChatPhraseInput[]·inputs; |
| 137 | 137 | ||
| 138 | » » [Header("Inclusion·Rules")] | ||
| 139 | » » [SerializeField] | 138 | » » [SerializeField] |
| 139 | » » [Header("Inclusion·Rules")] | ||
| 140 | » » private·QuickChatClassicPhraseRules·classicRules; | 140 | » » private·QuickChatClassicPhraseRules·classicRules; |
| 141 | 141 | ||
| 142 | » » [SerializeField] | 142 | » » [SerializeField] |
| 143 | » » private·QuickChatHideAndSeekPhraseRules·hideAndSeekRules; | 143 | » » private·QuickChatHideAndSeekPhraseRules·hideAndSeekRules; |
| 144 | 144 | ||
| 145 | » » private·QuickChatPhrase·cachedPhrase; | 145 | » » private·QuickChatPhrase·cachedPhrase; |
| 146 | » } | 146 | » } |
| Offset 56, 15 lines modified | Offset 56, 15 lines modified | ||
| 56 | » » » » return·"ERROR"; | 56 | » » » » return·"ERROR"; |
| 57 | » » » } | 57 | » » » } |
| 58 | » » » if·(playerID·==·255) | 58 | » » » if·(playerID·==·255) |
| 59 | » » » { | 59 | » » » { |
| 60 | » » » » QuickChatMenu.Logger.Warning("[QuickChatPhraseBuilderResult]·ToPlayerNameChatText()·Player·ID·is·empty.",·null); | 60 | » » » » QuickChatMenu.Logger.Warning("[QuickChatPhraseBuilderResult]·ToPlayerNameChatText()·Player·ID·is·empty.",·null); |
| 61 | » » » » return·"ERROR"; | 61 | » » » » return·"ERROR"; |
| 62 | » » » } | 62 | » » » } |
| 63 | » » » | 63 | » » » NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(playerID); |
| 64 | » » » if·(playerById·==·null) | 64 | » » » if·(playerById·==·null) |
| 65 | » » » { | 65 | » » » { |
| 66 | » » » » QuickChatMenu.Logger.Warning(string.Format("[{0}]·ToPlayerNameChatText()·Player·with·associated·ID·'{1}'·was·not·found.",·"QuickChatPhraseBuilderResult",·playerID),·null); | 66 | » » » » QuickChatMenu.Logger.Warning(string.Format("[{0}]·ToPlayerNameChatText()·Player·with·associated·ID·'{1}'·was·not·found.",·"QuickChatPhraseBuilderResult",·playerID),·null); |
| 67 | » » » » return·"ERROR"; | 67 | » » » » return·"ERROR"; |
| 68 | » » » } | 68 | » » » } |
| 69 | » » » if·(DataManager.Settings.Accessibility.ColorBlindMode) | 69 | » » » if·(DataManager.Settings.Accessibility.ColorBlindMode) |
| 70 | » » » { | 70 | » » » { |
| Offset 136, 16 lines modified | Offset 136, 16 lines modified | ||
| 136 | » » » » { | 136 | » » » » { |
| 137 | » » » » » text·+=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.QuickChatInstructionsChild,·Array.Empty<object>()); | 137 | » » » » » text·+=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.QuickChatInstructionsChild,·Array.Empty<object>()); |
| 138 | » » » » } | 138 | » » » » } |
| 139 | » » » } | 139 | » » » } |
| 140 | » » » return·text; | 140 | » » » return·text; |
| 141 | » » } | 141 | » » } |
| 142 | 142 | ||
| 143 | » » [Space(10f)] | ||
| 144 | » » [SerializeField] | 143 | » » [SerializeField] |
| 144 | » » [Space(10f)] | ||
| 145 | » » private·ChatInputFieldButton·clearButton; | 145 | » » private·ChatInputFieldButton·clearButton; |
| 146 | 146 | ||
| 147 | » » [SerializeField] | 147 | » » [SerializeField] |
| 148 | » » private·ChatInputFieldButton·undoButton; | 148 | » » private·ChatInputFieldButton·undoButton; |
| 149 | 149 | ||
| 150 | » » [SerializeField] | 150 | » » [SerializeField] |
| 151 | » » private·TextMeshPro·warningText; | 151 | » » private·TextMeshPro·warningText; |
| Offset 64, 15 lines modified | Offset 64, 15 lines modified | ||
| 64 | 64 | ||
| 65 | » » [SerializeField] | 65 | » » [SerializeField] |
| 66 | » » private·StringNames·tagKey; | 66 | » » private·StringNames·tagKey; |
| 67 | 67 | ||
| 68 | » » [SerializeField] | 68 | » » [SerializeField] |
| 69 | » » private·StringNames·inputKey; | 69 | » » private·StringNames·inputKey; |
| 70 | 70 | ||
| 71 | » » [ColorUsage(false)] | ||
| 72 | » » [SerializeField] | 71 | » » [SerializeField] |
| 72 | » » [ColorUsage(false)] | ||
| 73 | » » private·Color·color; | 73 | » » private·Color·color; |
| 74 | 74 | ||
| 75 | » » [SerializeField] | 75 | » » [SerializeField] |
| 76 | » » private·string[]·parsingKeys; | 76 | » » private·string[]·parsingKeys; |
| 77 | » } | 77 | » } |
| 78 | } | 78 | } |
| Offset 245, 16 lines modified | Offset 245, 16 lines modified | ||
| 245 | 245 | ||
| 246 | » » [SerializeField] | 246 | » » [SerializeField] |
| 247 | » » private·QuickChatTag·lobbyHiding; | 247 | » » private·QuickChatTag·lobbyHiding; |
| 248 | 248 | ||
| 249 | » » [SerializeField] | 249 | » » [SerializeField] |
| 250 | » » private·QuickChatTag·lobbyFlashlight; | 250 | » » private·QuickChatTag·lobbyFlashlight; |
| 251 | 251 | ||
| 252 | » » [Header("Collections")] | ||
| 253 | » » [SerializeField] | 252 | » » [SerializeField] |
| 253 | » » [Header("Collections")] | ||
| 254 | » » private·QuickChatTag[]·visibleInClassicLobby; | 254 | » » private·QuickChatTag[]·visibleInClassicLobby; |
| 255 | 255 | ||
| 256 | » » [SerializeField] | 256 | » » [SerializeField] |
| 257 | » » private·QuickChatTag[]·visibleInHideAndSeekLobby; | 257 | » » private·QuickChatTag[]·visibleInHideAndSeekLobby; |
| 258 | 258 | ||
| 259 | » » [SerializeField] | 259 | » » [SerializeField] |
| 260 | » » private·QuickChatTag[]·visibleInGame; | 260 | » » private·QuickChatTag[]·visibleInGame; |
| Offset 190, 14 lines modified | Offset 190, 16 lines modified | ||
| 190 | » » » DestroyableSingleton<WaitForHostPopup>.Instance.Hide(); | 190 | » » » DestroyableSingleton<WaitForHostPopup>.Instance.Hide(); |
| 191 | » » } | 191 | » » } |
| 192 | » » base.StopAllCoroutines(); | 192 | » » base.StopAllCoroutines(); |
| 193 | » » this.AbortLoadingAssets(); | 193 | » » this.AbortLoadingAssets(); |
| 194 | » » DestroyableSingleton<FriendsListManager>.Instance.ReparentUI(); | 194 | » » DestroyableSingleton<FriendsListManager>.Instance.ReparentUI(); |
| 195 | » » SoundManager.Instance.StopAllSound(); | 195 | » » SoundManager.Instance.StopAllSound(); |
| 196 | » » this.discoverState·=·DiscoveryState.Off; | 196 | » » this.discoverState·=·DiscoveryState.Off; |
| 197 | » » this.DestroyPlayerInfoObjects(); | ||
| 198 | » » GameData.DestroyInstance(); | ||
| 197 | » » this.DisconnectHandlers.Clear(); | 199 | » » this.DisconnectHandlers.Clear(); |
| 198 | » » base.DisconnectInternal(reason,·null); | 200 | » » base.DisconnectInternal(reason,·null); |
| 199 | » » DestroyableSingleton<AchievementManager>.Instance.OnMatchExited(); | 201 | » » DestroyableSingleton<AchievementManager>.Instance.OnMatchExited(); |
| 200 | » » GameDebugCommands.RemoveCommands(); | 202 | » » GameDebugCommands.RemoveCommands(); |
| 201 | » » global::Logger.GlobalInstance.Debug("Loading·new·scene·"·+·this.MainMenuScene,·null); | 203 | » » global::Logger.GlobalInstance.Debug("Loading·new·scene·"·+·this.MainMenuScene,·null); |
| 202 | » » SceneManager.LoadScene(this.MainMenuScene); | 204 | » » SceneManager.LoadScene(this.MainMenuScene); |
| 203 | » » global::Logger.GlobalInstance.Debug("Finished·loading·scene",·null); | 205 | » » global::Logger.GlobalInstance.Debug("Finished·loading·scene",·null); |
| Offset 280, 18 lines modified | Offset 282, 18 lines modified | ||
| 280 | » » » ShipStatus.Instance·=·result.GetComponent<ShipStatus>(); | 282 | » » » ShipStatus.Instance·=·result.GetComponent<ShipStatus>(); |
| 281 | » » » base.Spawn(ShipStatus.Instance,·-2,·SpawnFlags.None); | 283 | » » » base.Spawn(ShipStatus.Instance,·-2,·SpawnFlags.None); |
| 282 | » » } | 284 | » » } |
| 283 | » » float·timer·=·0f; | 285 | » » float·timer·=·0f; |
| 284 | » » for·(;;) | 286 | » » for·(;;) |
| 285 | » » { | 287 | » » { |
| 286 | » » » bool·stopWaiting·=·true; | 288 | » » » bool·stopWaiting·=·true; |
| 287 | » » » int·num2·=· | 289 | » » » int·num2·=·10; |
| 288 | » » » if·(GameOptionsManager.Instance.CurrentGameOptions.MapId·==·5·||·GameOptionsManager.Instance.CurrentGameOptions.MapId·==·4) | 290 | » » » if·(GameOptionsManager.Instance.CurrentGameOptions.MapId·==·5·||·GameOptionsManager.Instance.CurrentGameOptions.MapId·==·4) |
| 289 | » » » { | 291 | » » » { |
| 290 | » » » » num2·=· | 292 | » » » » num2·=·15; |
| 291 | » » » } | 293 | » » » } |
| 292 | » » » List<ClientData>·allClients·=·this.allClients; | 294 | » » » List<ClientData>·allClients·=·this.allClients; |
| 293 | » » » lock·(allClients) | 295 | » » » lock·(allClients) |
| 294 | » » » { | 296 | » » » { |
| 295 | » » » » for·(int·i·=·0;·i·<·this.allClients.Count;·i++) | 297 | » » » » for·(int·i·=·0;·i·<·this.allClients.Count;·i++) |
| 296 | » » » » { | 298 | » » » » { |
| 297 | » » » » » ClientData·clientData·=·this.allClients[i]; | 299 | » » » » » ClientData·clientData·=·this.allClients[i]; |
| Offset 319, 25 lines modified | Offset 321, 45 lines modified | ||
| 319 | » » } | 321 | » » } |
| 320 | » » DestroyableSingleton<RoleManager>.Instance.SelectRoles(); | 322 | » » DestroyableSingleton<RoleManager>.Instance.SelectRoles(); |
| 321 | » » ShipStatus.Instance.Begin(); | 323 | » » ShipStatus.Instance.Begin(); |
| 322 | » » base.SendClientReady(); | 324 | » » base.SendClientReady(); |
| 323 | » » yield·break; | 325 | » » yield·break; |
| 324 | » } | 326 | » } |
| 325 | 327 | ||
| 328 | » public·void·KickNotJoinedPlayers() | ||
| 329 | » { | ||
| 330 | » » if·(!base.AmHost) | ||
| 331 | » » { | ||
| 332 | » » » return; | ||
| 333 | » » } | ||
| 334 | » » List<ClientData>·allClients·=·this.allClients; | ||
| 335 | » » lock·(allClients) | ||
| 336 | » » { | ||
| 337 | » » » for·(int·i·=·0;·i·<·this.allClients.Count;·i++) | ||
| 338 | » » » { | ||
| 339 | » » » » ClientData·clientData·=·this.allClients[i]; | ||
| 340 | » » » » if·(clientData.Character·==·null) | ||
| 341 | » » » » { | ||
| 342 | » » » » » base.SendLateRejection(clientData.Id,·DisconnectReasons.Error); | ||
| 343 | » » » » } | ||
| 344 | » » » } | ||
| 345 | » » } | ||
| 346 | » } | ||
| 347 | |||
| 326 | » protected·IEnumerator·CoStartGameClient() | 348 | » protected·IEnumerator·CoStartGameClient() |
| 327 | » { | 349 | » { |
| 328 | » » while·(PlayerControl.LocalPlayer.Data·==·null·&&·!base.AmHost) | 350 | » » while·(PlayerControl.LocalPlayer.Data·==·null·&&·!base.AmHost) |
| 329 | » » { | 351 | » » { |
| 330 | » » » yield·return·null; | 352 | » » » yield·return·null; |
| 331 | » » } | 353 | » » } |
| 332 | » » float·timer·=·0f; | 354 | » » float·timer·=·0f; |
| 333 | » » float·timeOut·=· | 355 | » » float·timeOut·=·15f; |
| 334 | » » if·(GameOptionsManager.Instance.CurrentGameOptions.MapId·==·5·||·GameOptionsManager.Instance.CurrentGameOptions.MapId·==·4) | 356 | » » if·(GameOptionsManager.Instance.CurrentGameOptions.MapId·==·5·||·GameOptionsManager.Instance.CurrentGameOptions.MapId·==·4) |
| 335 | » » { | 357 | » » { |
| 336 | » » » timeOut·=· | 358 | » » » timeOut·=·20f; |
| 337 | » » } | 359 | » » } |
| 338 | » » while·(!ShipStatus.Instance·||·LobbyBehaviour.Instance) | 360 | » » while·(!ShipStatus.Instance·||·LobbyBehaviour.Instance) |
| 339 | » » { | 361 | » » { |
| 340 | » » » if·(base.AmHost) | 362 | » » » if·(base.AmHost) |
| 341 | » » » { | 363 | » » » { |
| 342 | » » » » yield·break; | 364 | » » » » yield·break; |
| 343 | » » » } | 365 | » » » } |
| Offset 429, 14 lines modified | Offset 451, 18 lines modified | ||
| 429 | » » » gameSettingMenu.Close(); | 451 | » » » gameSettingMenu.Close(); |
| 430 | » » } | 452 | » » } |
| 431 | » » if·(DestroyableSingleton<GameStartManager>.InstanceExists) | 453 | » » if·(DestroyableSingleton<GameStartManager>.InstanceExists) |
| 432 | » » { | 454 | » » { |
| 433 | » » » this.DisconnectHandlers.Remove(DestroyableSingleton<GameStartManager>.Instance); | 455 | » » » this.DisconnectHandlers.Remove(DestroyableSingleton<GameStartManager>.Instance); |
| 434 | » » » Object.Destroy(DestroyableSingleton<GameStartManager>.Instance.gameObject); | 456 | » » » Object.Destroy(DestroyableSingleton<GameStartManager>.Instance.gameObject); |
| 435 | » » } | 457 | » » } |
| 458 | » » if·(DestroyableSingleton<LobbyInfoPane>.InstanceExists) | ||
| 459 | » » { | ||
| 460 | » » » Object.Destroy(DestroyableSingleton<LobbyInfoPane>.Instance.gameObject); | ||
| 461 | » » } | ||
| 436 | » » if·(DestroyableSingleton<DiscordManager>.InstanceExists) | 462 | » » if·(DestroyableSingleton<DiscordManager>.InstanceExists) |
| 437 | » » { | 463 | » » { |
| 438 | » » » DestroyableSingleton<DiscordManager>.Instance.SetPlayingGame(); | 464 | » » » DestroyableSingleton<DiscordManager>.Instance.SetPlayingGame(); |
| 439 | » » } | 465 | » » } |
| 440 | » » if·(!string.IsNullOrEmpty(DataManager.Player.Store.ActiveCosmicube)) | 466 | » » if·(!string.IsNullOrEmpty(DataManager.Player.Store.ActiveCosmicube)) |
| 441 | » » { | 467 | » » { |
| 442 | » » » AmongUsClient.Instance.SetActivePodType(DestroyableSingleton<CosmicubeManager>.Instance.GetCubeDataByID(DataManager.Player.Store.ActiveCosmicube).podId); | 468 | » » » AmongUsClient.Instance.SetActivePodType(DestroyableSingleton<CosmicubeManager>.Instance.GetCubeDataByID(DataManager.Player.Store.ActiveCosmicube).podId); |
| Offset 447, 25 lines modified | Offset 473, 20 lines modified | ||
| 447 | » » » AmongUsClient.Instance.SetActivePodType(playerPrefs.ActivePodType); | 473 | » » » AmongUsClient.Instance.SetActivePodType(playerPrefs.ActivePodType); |
| 448 | » » } | 474 | » » } |
| 449 | » » DestroyableSingleton<FriendsListManager>.Instance.ConfirmationScreen.Cancel(); | 475 | » » DestroyableSingleton<FriendsListManager>.Instance.ConfirmationScreen.Cancel(); |
| 450 | » » DestroyableSingleton<FriendsListManager>.Instance.Ui.Close(true); | 476 | » » DestroyableSingleton<FriendsListManager>.Instance.Ui.Close(true); |
| 451 | » » DestroyableSingleton<FriendsListManager>.Instance.ReparentUI(); | 477 | » » DestroyableSingleton<FriendsListManager>.Instance.ReparentUI(); |
| 452 | » » CosmeticsCache.ClearUnusedCosmetics(); | 478 | » » CosmeticsCache.ClearUnusedCosmetics(); |
| 453 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·true); | 479 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·true); |
| 454 | » » while·(!GameData.Instance) | ||
| 455 | » » { | ||
| 456 | » » » yield·return·null; | ||
| 457 | » » } | ||
| 458 | » » StatsManager·instance·=·StatsManager.Instance; | 480 | » » StatsManager·instance·=·StatsManager.Instance; |
| 459 | » » float·banPoints·=·instance.BanPoints; | 481 | » » float·banPoints·=·instance.BanPoints; |
| 460 | » » instance.BanPoints·=·banPoints·+·1f; | 482 | » » instance.BanPoints·=·banPoints·+·1f; |
| 461 | » » StatsManager.Instance.LastGameStarted·=·DateTime.UtcNow; | 483 | » » StatsManager.Instance.LastGameStarted·=·DateTime.UtcNow; |
| 462 | » » if·(base.AmHost) | 484 | » » if·(base.AmHost) |
| 463 | » » { | 485 | » » { |
| 464 | » » » GameData.Instance.SetDirty(); | ||
| 465 | » » » yield·return·this.CoStartGameHost(); | 486 | » » » yield·return·this.CoStartGameHost(); |
| 466 | » » } | 487 | » » } |
| 467 | » » else | 488 | » » else |
| 468 | » » { | 489 | » » { |
| 469 | » » » yield·return·this.CoStartGameClient(); | 490 | » » » yield·return·this.CoStartGameClient(); |
| 470 | » » » if·(base.AmHost) | 491 | » » » if·(base.AmHost) |
| 471 | » » » { | 492 | » » » { |
| Offset 483, 22 lines modified | Offset 504, 22 lines modified | ||
| Max diff block lines reached; 16340/20790 bytes (78.60%) of diff not shown. | |||
| Offset 46, 19 lines modified | Offset 46, 24 lines modified | ||
| 46 | » { | 46 | » { |
| 47 | » » return·value·>·min·&&·value·<·max; | 47 | » » return·value·>·min·&&·value·<·max; |
| 48 | » } | 48 | » } |
| 49 | 49 | ||
| 50 | » protected·virtual·void·CloseBehaviour(Vector2·del,·float·delLen) | 50 | » protected·virtual·void·CloseBehaviour(Vector2·del,·float·delLen) |
| 51 | » { | 51 | » { |
| 52 | » » base.transform.position·=·this.target·-·del.normalized·*·0.6f; | 52 | » » base.transform.position·=·this.target·-·del.normalized·*·0.6f; |
| 53 | » » if·(this.alwaysMaxSize) | ||
| 54 | » » { | ||
| 55 | » » » base.transform.localScale·=·new·Vector3(this.MaxScale,·this.MaxScale,·this.MaxScale); | ||
| 56 | » » » return; | ||
| 57 | » » } | ||
| 53 | » » float·num·=·Mathf.Clamp(delLen,·0f,·this.MaxScale); | 58 | » » float·num·=·Mathf.Clamp(delLen,·0f,·this.MaxScale); |
| 54 | » » base.transform.localScale·=·new·Vector3(num,·num,·num); | 59 | » » base.transform.localScale·=·new·Vector3(num,·num,·num); |
| 55 | » } | 60 | » } |
| 56 | 61 | ||
| 57 | » protected·void·DistancedBehaviour(Vector2·vpPoint,·Vector2·del,·float·delLen,·Camera·cam) | 62 | » protected·virtual·void·DistancedBehaviour(Vector2·vpPoint,·Vector2·del,·float·delLen,·Camera·cam) |
| 58 | » { | 63 | » { |
| 59 | » » Vector2·vector·=·new·Vector2(Mathf.Clamp(vpPoint.x·*·2f·-·1f,·-1f,·1f),·Mathf.Clamp(vpPoint.y·*·2f·-·1f,·-1f,·1f)); | 64 | » » Vector2·vector·=·new·Vector2(Mathf.Clamp(vpPoint.x·*·2f·-·1f,·-1f,·1f),·Mathf.Clamp(vpPoint.y·*·2f·-·1f,·-1f,·1f)); |
| 60 | » » float·safeOrthographicSize·=·CameraSafeArea.GetSafeOrthographicSize(cam); | 65 | » » float·safeOrthographicSize·=·CameraSafeArea.GetSafeOrthographicSize(cam); |
| 61 | » » float·num·=·safeOrthographicSize·*·cam.aspect; | 66 | » » float·num·=·safeOrthographicSize·*·cam.aspect; |
| 62 | » » Vector3·vector2·=·new·Vector3(Mathf.LerpUnclamped(0f,·num·*·0.88f,·vector.x),·Mathf.LerpUnclamped(0f,·safeOrthographicSize·*·0.79f,·vector.y),·0f); | 67 | » » Vector3·vector2·=·new·Vector3(Mathf.LerpUnclamped(0f,·num·*·0.88f,·vector.x),·Mathf.LerpUnclamped(0f,·safeOrthographicSize·*·0.79f,·vector.y),·0f); |
| 63 | » » base.transform.position·=·cam.transform.position·+·vector2; | 68 | » » base.transform.position·=·cam.transform.position·+·vector2; |
| 64 | » » base.transform.localScale·=·new·Vector3(this.MaxScale,·this.MaxScale,·this.MaxScale); | 69 | » » base.transform.localScale·=·new·Vector3(this.MaxScale,·this.MaxScale,·this.MaxScale); |
| Offset 66, 12 lines modified | Offset 71, 14 lines modified | ||
| 66 | 71 | ||
| 67 | » public·Vector3·target; | 72 | » public·Vector3·target; |
| 68 | 73 | ||
| 69 | » public·float·perc·=·0.925f; | 74 | » public·float·perc·=·0.925f; |
| 70 | 75 | ||
| 71 | » public·float·MaxScale·=·1f; | 76 | » public·float·MaxScale·=·1f; |
| 72 | 77 | ||
| 78 | » public·bool·alwaysMaxSize; | ||
| 79 | |||
| 73 | » protected·float·minDistanceToShowArrow·=·0.3f; | 80 | » protected·float·minDistanceToShowArrow·=·0.3f; |
| 74 | 81 | ||
| 75 | » [HideInInspector] | 82 | » [HideInInspector] |
| 76 | » public·SpriteRenderer·image; | 83 | » public·SpriteRenderer·image; |
| 77 | } | 84 | } |
| Offset 58, 20 lines modified | Offset 58, 20 lines modified | ||
| 58 | » » }); | 58 | » » }); |
| 59 | » » if·(this.aspectPosition) | 59 | » » if·(this.aspectPosition) |
| 60 | » » { | 60 | » » { |
| 61 | » » » this.aspectPosition.DistanceFromEdge.x·=·this.originalDistanceFromEdge·+·(float)this.positionDirection·*·((this.allSprites[0].OriginalWidth·-·this.allSprites[0].Sprite.size.x)·/·2f); | 61 | » » » this.aspectPosition.DistanceFromEdge.x·=·this.originalDistanceFromEdge·+·(float)this.positionDirection·*·((this.allSprites[0].OriginalWidth·-·this.allSprites[0].Sprite.size.x)·/·2f); |
| 62 | » » } | 62 | » » } |
| 63 | » } | 63 | » } |
| 64 | 64 | ||
| 65 | » [SerializeField] | ||
| 66 | » [Header("Required")] | 65 | » [Header("Required")] |
| 66 | » [SerializeField] | ||
| 67 | » private·List<SpriteRenderer>·spritesToScale; | 67 | » private·List<SpriteRenderer>·spritesToScale; |
| 68 | 68 | ||
| 69 | » [Header("Optional")] | ||
| 70 | » [SerializeField] | 69 | » [SerializeField] |
| 70 | » [Header("Optional")] | ||
| 71 | » private·AspectPosition·aspectPosition; | 71 | » private·AspectPosition·aspectPosition; |
| 72 | 72 | ||
| 73 | » [SerializeField] | 73 | » [SerializeField] |
| 74 | » private·int·positionDirection·=·1; | 74 | » private·int·positionDirection·=·1; |
| 75 | 75 | ||
| 76 | » [SerializeField] | 76 | » [SerializeField] |
| 77 | » private·List<BoxCollider2D>·collidersToScale; | 77 | » private·List<BoxCollider2D>·collidersToScale; |
| Offset 1, 14 lines modified | Offset 1, 14 lines modified | ||
| 1 | <?xml·version="1.0"·encoding="utf-8"?> | 1 | <?xml·version="1.0"·encoding="utf-8"?> |
| 2 | <Project·xmlns="http://schemas.microsoft.com/developer/msbuild/2003"·ToolsVersion="15.0"> | 2 | <Project·xmlns="http://schemas.microsoft.com/developer/msbuild/2003"·ToolsVersion="15.0"> |
| 3 | ··<Import·Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props"·Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')"/> | 3 | ··<Import·Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props"·Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')"/> |
| 4 | ··<PropertyGroup> | 4 | ··<PropertyGroup> |
| 5 | ····<Configuration·Condition="·'$(Configuration)'·==·''·">Debug</Configuration> | 5 | ····<Configuration·Condition="·'$(Configuration)'·==·''·">Debug</Configuration> |
| 6 | ····<Platform·Condition="·'$(Platform)'·==·''·">AnyCPU</Platform> | 6 | ····<Platform·Condition="·'$(Platform)'·==·''·">AnyCPU</Platform> |
| 7 | ····<ProjectGuid>{ | 7 | ····<ProjectGuid>{2B08EEB2-0341-466B-8A98-2B231743DC3D}</ProjectGuid> |
| 8 | ····<OutputType>Library</OutputType> | 8 | ····<OutputType>Library</OutputType> |
| 9 | ····<RootNamespace>Assembly-CSharp</RootNamespace> | 9 | ····<RootNamespace>Assembly-CSharp</RootNamespace> |
| 10 | ····<AssemblyName>Assembly-CSharp</AssemblyName> | 10 | ····<AssemblyName>Assembly-CSharp</AssemblyName> |
| 11 | ····<TargetFrameworkVersion>v4.0</TargetFrameworkVersion> | 11 | ····<TargetFrameworkVersion>v4.0</TargetFrameworkVersion> |
| 12 | ····<FileAlignment>512</FileAlignment> | 12 | ····<FileAlignment>512</FileAlignment> |
| 13 | ··</PropertyGroup> | 13 | ··</PropertyGroup> |
| 14 | ··<PropertyGroup·Condition="·'$(Configuration)|$(Platform)'·==·'Debug|AnyCPU'·"> | 14 | ··<PropertyGroup·Condition="·'$(Configuration)|$(Platform)'·==·'Debug|AnyCPU'·"> |
| Offset 141, 15 lines modified | Offset 141, 15 lines modified | ||
| 141 | ····<Compile·Include="AchievementManager.cs"/> | 141 | ····<Compile·Include="AchievementManager.cs"/> |
| 142 | ····<Compile·Include="ActionButton.cs"/> | 142 | ····<Compile·Include="ActionButton.cs"/> |
| 143 | ····<Compile·Include="ActionMapGlyphDisplay.cs"/> | 143 | ····<Compile·Include="ActionMapGlyphDisplay.cs"/> |
| 144 | ····<Compile·Include="ActiveInputManager.cs"/> | 144 | ····<Compile·Include="ActiveInputManager.cs"/> |
| 145 | ····<Compile·Include="AdDataCollectScreen.cs"/> | 145 | ····<Compile·Include="AdDataCollectScreen.cs"/> |
| 146 | ····<Compile·Include="AdjustSteeringGame.cs"/> | 146 | ····<Compile·Include="AdjustSteeringGame.cs"/> |
| 147 | ····<Compile·Include="AdminButton.cs"/> | 147 | ····<Compile·Include="AdminButton.cs"/> |
| 148 | ····<Compile·Include="AdvancedRole | 148 | ····<Compile·Include="AdvancedRoleViewPanel.cs"/> |
| 149 | ····<Compile·Include="AgeGateScreen.cs"/> | 149 | ····<Compile·Include="AgeGateScreen.cs"/> |
| 150 | ····<Compile·Include="AirshipAuthGame.cs"/> | 150 | ····<Compile·Include="AirshipAuthGame.cs"/> |
| 151 | ····<Compile·Include="AirshipExileController.cs"/> | 151 | ····<Compile·Include="AirshipExileController.cs"/> |
| 152 | ····<Compile·Include="AirshipGarbageGame.cs"/> | 152 | ····<Compile·Include="AirshipGarbageGame.cs"/> |
| 153 | ····<Compile·Include="AirshipStatus.cs"/> | 153 | ····<Compile·Include="AirshipStatus.cs"/> |
| 154 | ····<Compile·Include="AirshipUploadGame.cs"/> | 154 | ····<Compile·Include="AirshipUploadGame.cs"/> |
| 155 | ····<Compile·Include="AirshipUploadTask.cs"/> | 155 | ····<Compile·Include="AirshipUploadTask.cs"/> |
| Offset 158, 14 lines modified | Offset 158, 32 lines modified | ||
| 158 | ····<Compile·Include="AlphaBlink.cs"/> | 158 | ····<Compile·Include="AlphaBlink.cs"/> |
| 159 | ····<Compile·Include="AlphaPulse.cs"/> | 159 | ····<Compile·Include="AlphaPulse.cs"/> |
| 160 | ····<Compile·Include="AmbientSoundPlayer.cs"/> | 160 | ····<Compile·Include="AmbientSoundPlayer.cs"/> |
| 161 | ····<Compile·Include="AmongUsClient.cs"/> | 161 | ····<Compile·Include="AmongUsClient.cs"/> |
| 162 | ····<Compile·Include="AmongUsControlMapper.cs"/> | 162 | ····<Compile·Include="AmongUsControlMapper.cs"/> |
| 163 | ····<Compile·Include="AmongUsProduct.cs"/> | 163 | ····<Compile·Include="AmongUsProduct.cs"/> |
| 164 | ····<Compile·Include="AmongUsServer\ExtensionFailureReasons.cs"/> | 164 | ····<Compile·Include="AmongUsServer\ExtensionFailureReasons.cs"/> |
| 165 | ····<Compile·Include="AmongUs\AnimationTestScene\AbstractAnimationTestScenePage.cs"/> | ||
| 166 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestScene.cs"/> | ||
| 167 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneButton.cs"/> | ||
| 168 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneColorsPage.cs"/> | ||
| 169 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneColorsPageBuilder.cs"/> | ||
| 170 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneColorsPageBuilderPresetButton.cs"/> | ||
| 171 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneColorsPageBuilderSprite.cs"/> | ||
| 172 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneColorsPageRenderer.cs"/> | ||
| 173 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneCosmeticData.cs"/> | ||
| 174 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneEjectPage.cs"/> | ||
| 175 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneExitPage.cs"/> | ||
| 176 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneInfoPage.cs"/> | ||
| 177 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneKillPage.cs"/> | ||
| 178 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneMeetingPage.cs"/> | ||
| 179 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestScenePetsPage.cs"/> | ||
| 180 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestScenePlayerPage.cs"/> | ||
| 181 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestScenePlayerPageBodyToggle.cs"/> | ||
| 182 | ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneTab.cs"/> | ||
| 165 | ····<Compile·Include="AmongUs\Data\AbstractSaveData.cs"/> | 183 | ····<Compile·Include="AmongUs\Data\AbstractSaveData.cs"/> |
| 166 | ····<Compile·Include="AmongUs\Data\AbstractSaveDataGroup.cs"/> | 184 | ····<Compile·Include="AmongUs\Data\AbstractSaveDataGroup.cs"/> |
| 167 | ····<Compile·Include="AmongUs\Data\AbstractUserSaveData.cs"/> | 185 | ····<Compile·Include="AmongUs\Data\AbstractUserSaveData.cs"/> |
| 168 | ····<Compile·Include="AmongUs\Data\DataManager.cs"/> | 186 | ····<Compile·Include="AmongUs\Data\DataManager.cs"/> |
| 169 | ····<Compile·Include="AmongUs\Data\ISaveDataGroupControl.cs"/> | 187 | ····<Compile·Include="AmongUs\Data\ISaveDataGroupControl.cs"/> |
| 170 | ····<Compile·Include="AmongUs\Data\Legacy\LegacySaveManager.cs"/> | 188 | ····<Compile·Include="AmongUs\Data\Legacy\LegacySaveManager.cs"/> |
| 171 | ····<Compile·Include="AmongUs\Data\Legacy\LegacySecureDataFile.cs"/> | 189 | ····<Compile·Include="AmongUs\Data\Legacy\LegacySecureDataFile.cs"/> |
| Offset 187, 38 lines modified | Offset 205, 52 lines modified | ||
| 187 | ····<Compile·Include="AmongUs\Data\Settings\MultiplayerSettingsData.cs"/> | 205 | ····<Compile·Include="AmongUs\Data\Settings\MultiplayerSettingsData.cs"/> |
| 188 | ····<Compile·Include="AmongUs\Data\Settings\SettingsData.cs"/> | 206 | ····<Compile·Include="AmongUs\Data\Settings\SettingsData.cs"/> |
| 189 | ····<Compile·Include="AmongUs\Data\Settings\VideoSettingsData.cs"/> | 207 | ····<Compile·Include="AmongUs\Data\Settings\VideoSettingsData.cs"/> |
| 190 | ····<Compile·Include="Amongus\GameModes\HideAndSeek\HideAndSeekMusicCollection.cs"/> | 208 | ····<Compile·Include="Amongus\GameModes\HideAndSeek\HideAndSeekMusicCollection.cs"/> |
| 191 | ····<Compile·Include="AmongUs\GameOptions\BoolOptionNames.cs"/> | 209 | ····<Compile·Include="AmongUs\GameOptions\BoolOptionNames.cs"/> |
| 192 | ····<Compile·Include="AmongUs\GameOptions\ByteOptionNames.cs"/> | 210 | ····<Compile·Include="AmongUs\GameOptions\ByteOptionNames.cs"/> |
| 193 | ····<Compile·Include="AmongUs\GameOptions\EngineerRoleOptionsV07.cs"/> | 211 | ····<Compile·Include="AmongUs\GameOptions\EngineerRoleOptionsV07.cs"/> |
| 212 | ····<Compile·Include="AmongUs\GameOptions\EngineerRoleOptionsV08.cs"/> | ||
| 194 | ····<Compile·Include="AmongUs\GameOptions\FloatArrayOptionNames.cs"/> | 213 | ····<Compile·Include="AmongUs\GameOptions\FloatArrayOptionNames.cs"/> |
| 195 | ····<Compile·Include="AmongUs\GameOptions\FloatOptionNames.cs"/> | 214 | ····<Compile·Include="AmongUs\GameOptions\FloatOptionNames.cs"/> |
| 196 | ····<Compile·Include="AmongUs\GameOptions\GameKeywords.cs"/> | 215 | ····<Compile·Include="AmongUs\GameOptions\GameKeywords.cs"/> |
| 197 | ····<Compile·Include="AmongUs\GameOptions\GameModes.cs"/> | 216 | ····<Compile·Include="AmongUs\GameOptions\GameModes.cs"/> |
| 198 | ····<Compile·Include="AmongUs\GameOptions\GameOptionsData.cs"/> | 217 | ····<Compile·Include="AmongUs\GameOptions\GameOptionsData.cs"/> |
| 199 | ····<Compile·Include="AmongUs\GameOptions\GameOptionsFactory.cs"/> | 218 | ····<Compile·Include="AmongUs\GameOptions\GameOptionsFactory.cs"/> |
| 200 | ····<Compile·Include="AmongUs\GameOptions\GameOptionsMigratorV06toV07.cs"/> | 219 | ····<Compile·Include="AmongUs\GameOptions\GameOptionsMigratorV06toV07.cs"/> |
| 220 | ····<Compile·Include="AmongUs\GameOptions\GameOptionsMigratorV07toV08.cs"/> | ||
| 201 | ····<Compile·Include="AmongUs\GameOptions\GuardianAngelRoleOptionsV07.cs"/> | 221 | ····<Compile·Include="AmongUs\GameOptions\GuardianAngelRoleOptionsV07.cs"/> |
| 222 | ····<Compile·Include="AmongUs\GameOptions\GuardianAngelRoleOptionsV08.cs"/> | ||
| 202 | ····<Compile·Include="AmongUs\GameOptions\HideNSeekGameOptionsV07.cs"/> | 223 | ····<Compile·Include="AmongUs\GameOptions\HideNSeekGameOptionsV07.cs"/> |
| 224 | ····<Compile·Include="AmongUs\GameOptions\HideNSeekGameOptionsV08.cs"/> | ||
| 203 | ····<Compile·Include="AmongUs\GameOptions\IGameOptions.cs"/> | 225 | ····<Compile·Include="AmongUs\GameOptions\IGameOptions.cs"/> |
| 204 | ····<Compile·Include="AmongUs\GameOptions\IGameOptionsMigrator.cs"/> | 226 | ····<Compile·Include="AmongUs\GameOptions\IGameOptionsMigrator.cs"/> |
| 205 | ····<Compile·Include="AmongUs\GameOptions\Int32ArrayOptionNames.cs"/> | 227 | ····<Compile·Include="AmongUs\GameOptions\Int32ArrayOptionNames.cs"/> |
| 206 | ····<Compile·Include="AmongUs\GameOptions\Int32OptionNames.cs"/> | 228 | ····<Compile·Include="AmongUs\GameOptions\Int32OptionNames.cs"/> |
| 207 | ····<Compile·Include="AmongUs\GameOptions\IRoleOptions.cs"/> | 229 | ····<Compile·Include="AmongUs\GameOptions\IRoleOptions.cs"/> |
| 208 | ····<Compile·Include="AmongUs\GameOptions\IRoleOptionsCollection.cs"/> | 230 | ····<Compile·Include="AmongUs\GameOptions\IRoleOptionsCollection.cs"/> |
| 231 | ····<Compile·Include="AmongUs\GameOptions\NoisemakerRoleOptionsV08.cs"/> | ||
| 209 | ····<Compile·Include="AmongUs\GameOptions\NormalGameOptionsV07.cs"/> | 232 | ····<Compile·Include="AmongUs\GameOptions\NormalGameOptionsV07.cs"/> |
| 233 | ····<Compile·Include="AmongUs\GameOptions\NormalGameOptionsV08.cs"/> | ||
| 234 | ····<Compile·Include="AmongUs\GameOptions\PhantomRoleOptionsV08.cs"/> | ||
| 210 | ····<Compile·Include="AmongUs\GameOptions\RoleDataV07.cs"/> | 235 | ····<Compile·Include="AmongUs\GameOptions\RoleDataV07.cs"/> |
| 236 | ····<Compile·Include="AmongUs\GameOptions\RoleDataV08.cs"/> | ||
| 211 | ····<Compile·Include="AmongUs\GameOptions\RoleOptionsCollectionV07.cs"/> | 237 | ····<Compile·Include="AmongUs\GameOptions\RoleOptionsCollectionV07.cs"/> |
| 238 | ····<Compile·Include="AmongUs\GameOptions\RoleOptionsCollectionV08.cs"/> | ||
| 212 | ····<Compile·Include="AmongUs\GameOptions\RoleOptionsData.cs"/> | 239 | ····<Compile·Include="AmongUs\GameOptions\RoleOptionsData.cs"/> |
| 213 | ····<Compile·Include="AmongUs\GameOptions\RoleRate.cs"/> | 240 | ····<Compile·Include="AmongUs\GameOptions\RoleRate.cs"/> |
| 214 | ····<Compile·Include="AmongUs\GameOptions\RoleTypes.cs"/> | 241 | ····<Compile·Include="AmongUs\GameOptions\RoleTypes.cs"/> |
| 242 | ····<Compile·Include="AmongUs\GameOptions\RulesPresets.cs"/> | ||
| 215 | ····<Compile·Include="AmongUs\GameOptions\ScientistRoleOptionsV07.cs"/> | 243 | ····<Compile·Include="AmongUs\GameOptions\ScientistRoleOptionsV07.cs"/> |
| 244 | ····<Compile·Include="AmongUs\GameOptions\ScientistRoleOptionsV08.cs"/> | ||
| 216 | ····<Compile·Include="AmongUs\GameOptions\ShapeshifterRoleOptionsV07.cs"/> | 245 | ····<Compile·Include="AmongUs\GameOptions\ShapeshifterRoleOptionsV07.cs"/> |
| 246 | ····<Compile·Include="AmongUs\GameOptions\ShapeshifterRoleOptionsV08.cs"/> | ||
| 247 | ····<Compile·Include="AmongUs\GameOptions\SpecialGameModes.cs"/> | ||
| 217 | ····<Compile·Include="AmongUs\GameOptions\TaskBarMode.cs"/> | 248 | ····<Compile·Include="AmongUs\GameOptions\TaskBarMode.cs"/> |
| 249 | ····<Compile·Include="AmongUs\GameOptions\TrackerRoleOptionsV08.cs"/> | ||
| 218 | ····<Compile·Include="AmongUs\GameOptions\UInt32OptionNames.cs"/> | 250 | ····<Compile·Include="AmongUs\GameOptions\UInt32OptionNames.cs"/> |
| 219 | ····<Compile·Include="AmongUs\HTTP\RetryableWebRequest.cs"/> | 251 | ····<Compile·Include="AmongUs\HTTP\RetryableWebRequest.cs"/> |
| 220 | ····<Compile·Include="AmongUs\QuickChat\AbstractQuickChatMenuPage.cs"/> | 252 | ····<Compile·Include="AmongUs\QuickChat\AbstractQuickChatMenuPage.cs"/> |
| 221 | ····<Compile·Include="AmongUs\QuickChat\AbstractQuickChatMenuPhrasesPageButton.cs"/> | 253 | ····<Compile·Include="AmongUs\QuickChat\AbstractQuickChatMenuPhrasesPageButton.cs"/> |
| 222 | ····<Compile·Include="AmongUs\QuickChat\AbstractQuickChatPhraseRuleGroup.cs"/> | 254 | ····<Compile·Include="AmongUs\QuickChat\AbstractQuickChatPhraseRuleGroup.cs"/> |
| 223 | ····<Compile·Include="AmongUs\QuickChat\IQuickChatPhraseCollector.cs"/> | 255 | ····<Compile·Include="AmongUs\QuickChat\IQuickChatPhraseCollector.cs"/> |
| 224 | ····<Compile·Include="AmongUs\QuickChat\QuickChatBreadcrumb.cs"/> | 256 | ····<Compile·Include="AmongUs\QuickChat\QuickChatBreadcrumb.cs"/> |
| Offset 322, 14 lines modified | Offset 354, 15 lines modified | ||
| 322 | ····<Compile·Include="AutoScroll.cs"/> | 354 | ····<Compile·Include="AutoScroll.cs"/> |
| 323 | ····<Compile·Include="AutoTaskConsole.cs"/> | 355 | ····<Compile·Include="AutoTaskConsole.cs"/> |
| 324 | ····<Compile·Include="AxisDirection.cs"/> | 356 | ····<Compile·Include="AxisDirection.cs"/> |
| 325 | ····<Compile·Include="BackendEndpoints.cs"/> | 357 | ····<Compile·Include="BackendEndpoints.cs"/> |
| 326 | ····<Compile·Include="BalloonBehaviour.cs"/> | 358 | ····<Compile·Include="BalloonBehaviour.cs"/> |
| 327 | ····<Compile·Include="BanButton.cs"/> | 359 | ····<Compile·Include="BanButton.cs"/> |
| 328 | ····<Compile·Include="BanMenu.cs"/> | 360 | ····<Compile·Include="BanMenu.cs"/> |
| 361 | ····<Compile·Include="BaseGameSetting.cs"/> | ||
| 329 | ····<Compile·Include="BlockedPlayerBar.cs"/> | 362 | ····<Compile·Include="BlockedPlayerBar.cs"/> |
| 330 | ····<Compile·Include="BlockedWords.cs"/> | 363 | ····<Compile·Include="BlockedWords.cs"/> |
| Max diff block lines reached; 18249/26508 bytes (68.84%) of diff not shown. | |||
| Offset 7, 15 lines modified | Offset 7, 15 lines modified | ||
| 7 | public·class·BanMenu·:·MonoBehaviour | 7 | public·class·BanMenu·:·MonoBehaviour |
| 8 | { | 8 | { |
| 9 | » public·void·SetVisible(bool·show) | 9 | » public·void·SetVisible(bool·show) |
| 10 | » { | 10 | » { |
| 11 | » » bool·flag; | 11 | » » bool·flag; |
| 12 | » » if·(PlayerControl.LocalPlayer) | 12 | » » if·(PlayerControl.LocalPlayer) |
| 13 | » » { | 13 | » » { |
| 14 | » » » | 14 | » » » NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data; |
| 15 | » » » flag·=·data·!=·null·&&·!data.IsDead; | 15 | » » » flag·=·data·!=·null·&&·!data.IsDead; |
| 16 | » » } | 16 | » » } |
| 17 | » » else | 17 | » » else |
| 18 | » » { | 18 | » » { |
| 19 | » » » flag·=·false; | 19 | » » » flag·=·false; |
| 20 | » » } | 20 | » » } |
| 21 | » » bool·flag2·=·flag; | 21 | » » bool·flag2·=·flag; |
| Offset 248, 16 lines modified | Offset 248, 16 lines modified | ||
| 248 | 248 | ||
| 249 | » public·int·selectedClientId·=·-1; | 249 | » public·int·selectedClientId·=·-1; |
| 250 | 250 | ||
| 251 | » public·List<BanButton>·allButtons·=·new·List<BanButton>(); | 251 | » public·List<BanButton>·allButtons·=·new·List<BanButton>(); |
| 252 | 252 | ||
| 253 | » private·List<ClientData>·recentClients·=·new·List<ClientData>(); | 253 | » private·List<ClientData>·recentClients·=·new·List<ClientData>(); |
| 254 | 254 | ||
| 255 | » [Header("Alignment·Settings")] | ||
| 256 | » [SerializeField] | 255 | » [SerializeField] |
| 256 | » [Header("Alignment·Settings")] | ||
| 257 | » private·float·backgroundTailWidth·=·0.4f; | 257 | » private·float·backgroundTailWidth·=·0.4f; |
| 258 | 258 | ||
| 259 | » [SerializeField] | 259 | » [SerializeField] |
| 260 | » private·float·backgroundBaseWidth·=·3.2f; | 260 | » private·float·backgroundBaseWidth·=·3.2f; |
| 261 | 261 | ||
| 262 | » [SerializeField] | 262 | » [SerializeField] |
| 263 | » private·float·backgroundBaseHeight·=·1.2f; | 263 | » private·float·backgroundBaseHeight·=·1.2f; |
| Offset 108, 16 lines modified | Offset 108, 16 lines modified | ||
| 108 | » » { | 108 | » » { |
| 109 | » » » this.descriptionCharacterCount.color·=·new·Color(1f,·1f,·0f,·1f); | 109 | » » » this.descriptionCharacterCount.color·=·new·Color(1f,·1f,·0f,·1f); |
| 110 | » » » return; | 110 | » » » return; |
| 111 | » » } | 111 | » » } |
| 112 | » » this.descriptionCharacterCount.color·=·Color.red; | 112 | » » this.descriptionCharacterCount.color·=·Color.red; |
| 113 | » } | 113 | » } |
| 114 | 114 | ||
| 115 | » [SerializeField] | ||
| 116 | » [Header("Buttons")] | 115 | » [Header("Buttons")] |
| 116 | » [SerializeField] | ||
| 117 | » private·PassiveButton[]·closeButtons; | 117 | » private·PassiveButton[]·closeButtons; |
| 118 | 118 | ||
| 119 | » [SerializeField] | 119 | » [SerializeField] |
| 120 | » private·PassiveButton·submitButton; | 120 | » private·PassiveButton·submitButton; |
| 121 | 121 | ||
| 122 | » [Header("Form")] | 122 | » [Header("Form")] |
| 123 | » [SerializeField] | 123 | » [SerializeField] |
| Offset 128, 16 lines modified | Offset 128, 16 lines modified | ||
| 128 | 128 | ||
| 129 | » [SerializeField] | 129 | » [SerializeField] |
| 130 | » private·PassiveButton·descriptionFieldButton; | 130 | » private·PassiveButton·descriptionFieldButton; |
| 131 | 131 | ||
| 132 | » [SerializeField] | 132 | » [SerializeField] |
| 133 | » private·Checkbox·attachScreenshotCheckbox; | 133 | » private·Checkbox·attachScreenshotCheckbox; |
| 134 | 134 | ||
| 135 | » [Header("Feedback·&·Validation")] | ||
| 136 | » [SerializeField] | 135 | » [SerializeField] |
| 136 | » [Header("Feedback·&·Validation")] | ||
| 137 | » private·TextMeshPro·descriptionCharacterCount; | 137 | » private·TextMeshPro·descriptionCharacterCount; |
| 138 | 138 | ||
| 139 | » [SerializeField] | 139 | » [SerializeField] |
| 140 | » private·TextMeshPro·submittedText; | 140 | » private·TextMeshPro·submittedText; |
| 141 | 141 | ||
| 142 | » [SerializeField] | 142 | » [SerializeField] |
| 143 | » [Header("Console·Controller·Navigation")] | 143 | » [Header("Console·Controller·Navigation")] |
| Offset 109, 32 lines modified | Offset 109, 32 lines modified | ||
| 109 | » » { | 109 | » » { |
| 110 | » » » SoundManager.Instance.PlaySound(this.completeSound,·false,·1f,·null); | 110 | » » » SoundManager.Instance.PlaySound(this.completeSound,·false,·1f,·null); |
| 111 | » » } | 111 | » » } |
| 112 | » } | 112 | » } |
| 113 | 113 | ||
| 114 | » private·const·float·CLOSE_ENOUGH_TO_TOP·=·0.8f; | 114 | » private·const·float·CLOSE_ENOUGH_TO_TOP·=·0.8f; |
| 115 | 115 | ||
| 116 | » [Tooltip("The·speed·at·which·lifting·with·an·analog·stick·moves·towards·the·true·lift·value.")] | ||
| 117 | » [SerializeField] | ||
| 118 | » [Header("Timing")] | 116 | » [Header("Timing")] |
| 117 | » [SerializeField] | ||
| 118 | » [Tooltip("The·speed·at·which·lifting·with·an·analog·stick·moves·towards·the·true·lift·value.")] | ||
| 119 | » private·float·liftLerpSpeed·=·5f; | 119 | » private·float·liftLerpSpeed·=·5f; |
| 120 | 120 | ||
| 121 | » [Tooltip("The·acceleration·at·which·the·bucket·falls·back·down,·per·second.·(Added·to·fallVelocity·per·second)")] | ||
| 122 | » [SerializeField] | 121 | » [SerializeField] |
| 122 | » [Tooltip("The·acceleration·at·which·the·bucket·falls·back·down,·per·second.·(Added·to·fallVelocity·per·second)")] | ||
| 123 | » private·float·fallGravity·=·0.5f; | 123 | » private·float·fallGravity·=·0.5f; |
| 124 | 124 | ||
| 125 | » [SerializeField] | ||
| 126 | » [Header("Lift·Range")] | 125 | » [Header("Lift·Range")] |
| 126 | » [SerializeField] | ||
| 127 | » private·Transform·startPosition; | 127 | » private·Transform·startPosition; |
| 128 | 128 | ||
| 129 | » [SerializeField] | 129 | » [SerializeField] |
| 130 | » private·Transform·endPosition; | 130 | » private·Transform·endPosition; |
| 131 | 131 | ||
| 132 | » [Header("Bucket")] | ||
| 133 | » [SerializeField] | 132 | » [SerializeField] |
| 133 | » [Header("Bucket")] | ||
| 134 | » private·Collider2D·bucketCollider; | 134 | » private·Collider2D·bucketCollider; |
| 135 | 135 | ||
| 136 | » [SerializeField] | 136 | » [SerializeField] |
| 137 | » private·SpriteRenderer·bucketSprite; | 137 | » private·SpriteRenderer·bucketSprite; |
| 138 | 138 | ||
| 139 | » [SerializeField] | 139 | » [SerializeField] |
| 140 | » private·SpriteRenderer·bucketBackSprite; | 140 | » private·SpriteRenderer·bucketBackSprite; |
| Offset 35, 15 lines modified | Offset 35, 15 lines modified | ||
| 35 | » » } | 35 | » » } |
| 36 | » } | 36 | » } |
| 37 | 37 | ||
| 38 | » public·LimitedTimeStartEnd·LimitedTimeAvailable | 38 | » public·LimitedTimeStartEnd·LimitedTimeAvailable |
| 39 | » { | 39 | » { |
| 40 | » » get | 40 | » » get |
| 41 | » » { | 41 | » » { |
| 42 | » » » return· | 42 | » » » return·this.limitedTime; |
| 43 | » » } | 43 | » » } |
| 44 | » } | 44 | » } |
| 45 | 45 | ||
| 46 | » public·string·GetItemName() | 46 | » public·string·GetItemName() |
| 47 | » { | 47 | » { |
| 48 | » » return·DestroyableSingleton<TranslationController>.Instance.GetString("Bundle."·+·this.productId,·this.productId,·Array.Empty<object>()); | 48 | » » return·DestroyableSingleton<TranslationController>.Instance.GetString("Bundle."·+·this.productId,·this.productId,·Array.Empty<object>()); |
| 49 | » } | 49 | » } |
| Offset 81, 8 lines modified | Offset 81, 11 lines modified | ||
| 81 | » public·Sprite·StoreImage; | 81 | » public·Sprite·StoreImage; |
| 82 | 82 | ||
| 83 | » public·bool·NotInStore; | 83 | » public·bool·NotInStore; |
| 84 | 84 | ||
| 85 | » public·bool·Free; | 85 | » public·bool·Free; |
| 86 | 86 | ||
| 87 | » public·bool·paidOnMobile; | 87 | » public·bool·paidOnMobile; |
| 88 | |||
| 89 | » [SerializeField] | ||
| 90 | » private·LimitedTimeStartEnd·limitedTime; | ||
| 88 | } | 91 | } |
| Offset 241, 16 lines modified | Offset 241, 16 lines modified | ||
| 241 | 241 | ||
| 242 | » private·const·float·SECONDS_TO_WAIT_FOR_FISH_TO_BE_CAUGHT·=·5f; | 242 | » private·const·float·SECONDS_TO_WAIT_FOR_FISH_TO_BE_CAUGHT·=·5f; |
| 243 | 243 | ||
| 244 | » private·const·float·LIGHTLY_BOBBING·=·0.02f; | 244 | » private·const·float·LIGHTLY_BOBBING·=·0.02f; |
| 245 | 245 | ||
| 246 | » private·const·float·STRONGLY_BOBBING·=·0.1f; | 246 | » private·const·float·STRONGLY_BOBBING·=·0.1f; |
| 247 | 247 | ||
| 248 | » [Header("Fishing·Rod")] | ||
| 249 | » [SerializeField] | 248 | » [SerializeField] |
| 249 | » [Header("Fishing·Rod")] | ||
| 250 | » private·Transform·fishingRod; | 250 | » private·Transform·fishingRod; |
| 251 | 251 | ||
| 252 | » [SerializeField] | 252 | » [SerializeField] |
| 253 | » private·SpriteRenderer·fishingLine; | 253 | » private·SpriteRenderer·fishingLine; |
| 254 | 254 | ||
| 255 | » [SerializeField] | 255 | » [SerializeField] |
| 256 | » private·Vector3·rodPutAwayPosition; | 256 | » private·Vector3·rodPutAwayPosition; |
| Offset 289, 16 lines modified | Offset 289, 16 lines modified | ||
| 289 | 289 | ||
| 290 | » [SerializeField] | 290 | » [SerializeField] |
| 291 | » private·Transform·alert; | 291 | » private·Transform·alert; |
| 292 | 292 | ||
| 293 | » [SerializeField] | 293 | » [SerializeField] |
| 294 | » private·float·caughtFishScale; | 294 | » private·float·caughtFishScale; |
| 295 | 295 | ||
| 296 | » [Header("Audio")] | ||
| 297 | » [SerializeField] | 296 | » [SerializeField] |
| 297 | » [Header("Audio")] | ||
| 298 | » private·AudioClip·onHookSfx; | 298 | » private·AudioClip·onHookSfx; |
| 299 | 299 | ||
| 300 | » [SerializeField] | 300 | » [SerializeField] |
| 301 | » private·AudioClip·onMissSfx; | 301 | » private·AudioClip·onMissSfx; |
| 302 | 302 | ||
| 303 | » [SerializeField] | 303 | » [SerializeField] |
| 304 | » private·AudioClip·onCatchSfx; | 304 | » private·AudioClip·onCatchSfx; |
| Offset 50, 15 lines modified | Offset 50, 15 lines modified | ||
| 50 | » » this.TextArea.color·=·Color.red; | 50 | » » this.TextArea.color·=·Color.red; |
| 51 | » » this.SetText(text); | 51 | » » this.SetText(text); |
| 52 | » » this.TextArea.rectTransform.pivot·=·new·Vector2(0f,·0f); | 52 | » » this.TextArea.rectTransform.pivot·=·new·Vector2(0f,·0f); |
| 53 | » » this.TextArea.transform.localPosition·=·new·Vector3(-0.25f,·-0.15f,·0f); | 53 | » » this.TextArea.transform.localPosition·=·new·Vector3(-0.25f,·-0.15f,·0f); |
| 54 | » » this.TextArea.horizontalAlignment·=·HorizontalAlignmentOptions.Left; | 54 | » » this.TextArea.horizontalAlignment·=·HorizontalAlignmentOptions.Left; |
| 55 | » } | 55 | » } |
| 56 | 56 | ||
| 57 | » public·void·SetCosmetics( | 57 | » public·void·SetCosmetics(NetworkedPlayerInfo·playerInfo) |
| 58 | » { | 58 | » { |
| 59 | » » this.playerInfo·=·playerInfo; | 59 | » » this.playerInfo·=·playerInfo; |
| 60 | » » if·(base.gameObject.activeInHierarchy) | 60 | » » if·(base.gameObject.activeInHierarchy) |
| 61 | » » { | 61 | » » { |
| 62 | » » » this.Player.UpdateFromEitherPlayerDataOrCache(playerInfo,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ScrollingUI,·false,·null); | 62 | » » » this.Player.UpdateFromEitherPlayerDataOrCache(playerInfo,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ScrollingUI,·false,·null); |
| 63 | » » } | 63 | » » } |
| 64 | » » this.Player.ToggleName(false); | 64 | » » this.Player.ToggleName(false); |
| Offset 179, 11 lines modified | Offset 179, 11 lines modified | ||
| 179 | 179 | ||
| 180 | » public·SpriteRenderer·MaskArea; | 180 | » public·SpriteRenderer·MaskArea; |
| 181 | 181 | ||
| 182 | » public·PlatformIdentifier·PlatformIcon; | 182 | » public·PlatformIdentifier·PlatformIcon; |
| 183 | 183 | ||
| 184 | » public·TextMeshPro·ColorBlindName; | 184 | » public·TextMeshPro·ColorBlindName; |
| 185 | 185 | ||
| 186 | » private· | 186 | » private·NetworkedPlayerInfo·playerInfo; |
| 187 | 187 | ||
| 188 | » private·int·maskLayer; | 188 | » private·int·maskLayer; |
| 189 | } | 189 | } |
| Offset 193, 14 lines modified | Offset 193, 15 lines modified | ||
| 193 | » » base.StopAllCoroutines(); | 193 | » » base.StopAllCoroutines(); |
| 194 | » » this.quickChatMenu.CloseImmediately(); | 194 | » » this.quickChatMenu.CloseImmediately(); |
| 195 | » » this.freeChatField.Unfocus(); | 195 | » » this.freeChatField.Unfocus(); |
| 196 | » » this.chatScreen.SetActive(false); | 196 | » » this.chatScreen.SetActive(false); |
| 197 | » » this.banButton.SetVisible(false); | 197 | » » this.banButton.SetVisible(false); |
| 198 | » » this.banButton.Hide(); | 198 | » » this.banButton.Hide(); |
| 199 | » » this.state·=·ChatControllerState.Closed; | 199 | » » this.state·=·ChatControllerState.Closed; |
| 200 | » » this.chatButton.SelectButton(false); | ||
| 200 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | 201 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) |
| 201 | » » { | 202 | » » { |
| 202 | » » » DestroyableSingleton<HudManager>.Instance.ToggleMapButtonGlyph(true); | 203 | » » » DestroyableSingleton<HudManager>.Instance.ToggleMapButtonGlyph(true); |
| 203 | » » } | 204 | » » } |
| 204 | » » if·(DestroyableSingleton<GameStartManager>.InstanceExists) | 205 | » » if·(DestroyableSingleton<GameStartManager>.InstanceExists) |
| 205 | » » { | 206 | » » { |
| 206 | » » » DestroyableSingleton<GameStartManager>.Instance.ToggleButtonGlyphs(true); | 207 | » » » DestroyableSingleton<GameStartManager>.Instance.ToggleButtonGlyphs(true); |
| Offset 212, 14 lines modified | Offset 213, 18 lines modified | ||
| 212 | » public·void·Toggle() | 213 | » public·void·Toggle() |
| 213 | » { | 214 | » { |
| 214 | » » CustomNetworkTransform·customNetworkTransform·=·(PlayerControl.LocalPlayer·?·PlayerControl.LocalPlayer.NetTransform·:·null); | 215 | » » CustomNetworkTransform·customNetworkTransform·=·(PlayerControl.LocalPlayer·?·PlayerControl.LocalPlayer.NetTransform·:·null); |
| 215 | » » if·(!customNetworkTransform·||·DestroyableSingleton<FriendsListManager>.Instance.Ui.gameObject.activeSelf) | 216 | » » if·(!customNetworkTransform·||·DestroyableSingleton<FriendsListManager>.Instance.Ui.gameObject.activeSelf) |
| 216 | » » { | 217 | » » { |
| 217 | » » » return; | 218 | » » » return; |
| 218 | » » } | 219 | » » } |
| 220 | » » if·(PlayerCustomizationMenu.Instance·&&·PlayerCustomizationMenu.Instance.cosmicubeMenu.activeSelf) | ||
| 221 | » » { | ||
| 222 | » » » return; | ||
| 223 | » » } | ||
| 219 | » » base.StopAllCoroutines(); | 224 | » » base.StopAllCoroutines(); |
| 220 | » » if·(this.IsOpenOrOpening) | 225 | » » if·(this.IsOpenOrOpening) |
| 221 | » » { | 226 | » » { |
| 222 | » » » base.StartCoroutine(this.CoClose()); | 227 | » » » base.StartCoroutine(this.CoClose()); |
| 223 | » » » if·(DestroyableSingleton<FriendsListManager>.InstanceExists) | 228 | » » » if·(DestroyableSingleton<FriendsListManager>.InstanceExists) |
| 224 | » » » { | 229 | » » » { |
| 225 | » » » » DestroyableSingleton<FriendsListManager>.Instance.SetFriendButtonColor(false); | 230 | » » » » DestroyableSingleton<FriendsListManager>.Instance.SetFriendButtonColor(false); |
| Offset 250, 14 lines modified | Offset 255, 15 lines modified | ||
| 250 | 255 | ||
| 251 | » private·IEnumerator·CoOpen() | 256 | » private·IEnumerator·CoOpen() |
| 252 | » { | 257 | » { |
| 253 | » » this.CheckKeyboardButton(); | 258 | » » this.CheckKeyboardButton(); |
| 254 | » » this.state·=·ChatControllerState.Opening; | 259 | » » this.state·=·ChatControllerState.Opening; |
| 255 | » » float·duration·=·Enumerable.Last<Keyframe>(this.chatAnimationIn.keys).time; | 260 | » » float·duration·=·Enumerable.Last<Keyframe>(this.chatAnimationIn.keys).time; |
| 256 | » » this.chatButtonAspectPosition.AdjustPosition(); | 261 | » » this.chatButtonAspectPosition.AdjustPosition(); |
| 262 | » » this.chatButton.SelectButton(true); | ||
| 257 | » » this.quickChatMenu.Clear(); | 263 | » » this.quickChatMenu.Clear(); |
| 258 | » » this.quickChatField.Clear(); | 264 | » » this.quickChatField.Clear(); |
| 259 | » » this.quickChatMenu.Close(); | 265 | » » this.quickChatMenu.Close(); |
| 260 | » » this.banButton.Hide(); | 266 | » » this.banButton.Hide(); |
| 261 | » » this.banButton.SetVisible(true); | 267 | » » this.banButton.SetVisible(true); |
| 262 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | 268 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) |
| 263 | » » { | 269 | » » { |
| Offset 290, 14 lines modified | Offset 296, 15 lines modified | ||
| 290 | » » yield·break; | 296 | » » yield·break; |
| 291 | » } | 297 | » } |
| 292 | 298 | ||
| 293 | » private·IEnumerator·CoClose() | 299 | » private·IEnumerator·CoClose() |
| 294 | » { | 300 | » { |
| 295 | » » this.state·=·ChatControllerState.Closing; | 301 | » » this.state·=·ChatControllerState.Closing; |
| 296 | » » float·duration·=·Enumerable.Last<Keyframe>(this.chatAnimationOut.keys).time; | 302 | » » float·duration·=·Enumerable.Last<Keyframe>(this.chatAnimationOut.keys).time; |
| 303 | » » this.chatButton.SelectButton(false); | ||
| 297 | » » this.quickChatMenu.Close(); | 304 | » » this.quickChatMenu.Close(); |
| 298 | » » this.banButton.Hide(); | 305 | » » this.banButton.Hide(); |
| 299 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | 306 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) |
| 300 | » » { | 307 | » » { |
| 301 | » » » DestroyableSingleton<HudManager>.Instance.ToggleMapButtonGlyph(true); | 308 | » » » DestroyableSingleton<HudManager>.Instance.ToggleMapButtonGlyph(true); |
| 302 | » » } | 309 | » » } |
| 303 | » » if·(DestroyableSingleton<GameStartManager>.InstanceExists) | 310 | » » if·(DestroyableSingleton<GameStartManager>.InstanceExists) |
| Offset 322, 15 lines modified | Offset 329, 15 lines modified | ||
| 322 | » » ConsoleJoystick.SetMode_Menu(); | 329 | » » ConsoleJoystick.SetMode_Menu(); |
| 323 | » » ControllerManager.Instance.CloseOverlayMenu(base.name); | 330 | » » ControllerManager.Instance.CloseOverlayMenu(base.name); |
| 324 | » » this.state·=·ChatControllerState.Closed; | 331 | » » this.state·=·ChatControllerState.Closed; |
| 325 | » » this.freeChatField.ForceKeyboardClose(); | 332 | » » this.freeChatField.ForceKeyboardClose(); |
| 326 | » » yield·break; | 333 | » » yield·break; |
| 327 | » } | 334 | » } |
| 328 | 335 | ||
| 329 | » public·void·AddChatNote( | 336 | » public·void·AddChatNote(NetworkedPlayerInfo·srcPlayer,·ChatNoteTypes·noteType) |
| 330 | » { | 337 | » { |
| 331 | » » if·(srcPlayer·==·null) | 338 | » » if·(srcPlayer·==·null) |
| 332 | » » { | 339 | » » { |
| 333 | » » » return; | 340 | » » » return; |
| 334 | » » } | 341 | » » } |
| 335 | » » ChatBubble·pooledBubble·=·this.GetPooledBubble(); | 342 | » » ChatBubble·pooledBubble·=·this.GetPooledBubble(); |
| 336 | » » pooledBubble.SetCosmetics(srcPlayer); | 343 | » » pooledBubble.SetCosmetics(srcPlayer); |
| Offset 357, 16 lines modified | Offset 364, 16 lines modified | ||
| 357 | 364 | ||
| 358 | » public·void·AddChat(PlayerControl·sourcePlayer,·string·chatText,·bool·censor·=·true) | 365 | » public·void·AddChat(PlayerControl·sourcePlayer,·string·chatText,·bool·censor·=·true) |
| 359 | » { | 366 | » { |
| 360 | » » if·(!sourcePlayer·||·!PlayerControl.LocalPlayer) | 367 | » » if·(!sourcePlayer·||·!PlayerControl.LocalPlayer) |
| 361 | » » { | 368 | » » { |
| 362 | » » » return; | 369 | » » » return; |
| 363 | » » } | 370 | » » } |
| 364 | » » | 371 | » » NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data; |
| 365 | » » | 372 | » » NetworkedPlayerInfo·data2·=·sourcePlayer.Data; |
| 366 | » » if·(data2·==·null·||·data·==·null·||·(data2.IsDead·&&·!data.IsDead)) | 373 | » » if·(data2·==·null·||·data·==·null·||·(data2.IsDead·&&·!data.IsDead)) |
| 367 | » » { | 374 | » » { |
| 368 | » » » return; | 375 | » » » return; |
| 369 | » » } | 376 | » » } |
| 370 | » » ChatBubble·pooledBubble·=·this.GetPooledBubble(); | 377 | » » ChatBubble·pooledBubble·=·this.GetPooledBubble(); |
| 371 | » » try | 378 | » » try |
| 372 | » » { | 379 | » » { |
| Offset 394, 14 lines modified | Offset 401, 15 lines modified | ||
| 394 | » » » if·(!this.IsOpenOrOpening·&&·this.notificationRoutine·==·null) | 401 | » » » if·(!this.IsOpenOrOpening·&&·this.notificationRoutine·==·null) |
| 395 | » » » { | 402 | » » » { |
| 396 | » » » » this.notificationRoutine·=·base.StartCoroutine(this.BounceDot()); | 403 | » » » » this.notificationRoutine·=·base.StartCoroutine(this.BounceDot()); |
| 397 | » » » } | 404 | » » » } |
| 398 | » » » if·(!flag) | 405 | » » » if·(!flag) |
| 399 | » » » { | 406 | » » » { |
| 400 | » » » » SoundManager.Instance.PlaySound(this.messageSound,·false,·1f,·null).pitch·=·0.5f·+·(float)sourcePlayer.PlayerId·/·15f; | 407 | » » » » SoundManager.Instance.PlaySound(this.messageSound,·false,·1f,·null).pitch·=·0.5f·+·(float)sourcePlayer.PlayerId·/·15f; |
| 408 | » » » » this.chatNotification.SetUp(sourcePlayer,·chatText); | ||
| 401 | » » » } | 409 | » » » } |
| 402 | » » } | 410 | » » } |
| 403 | » » catch·(Exception·ex) | 411 | » » catch·(Exception·ex) |
| 404 | » » { | 412 | » » { |
| 405 | » » » ChatController.Logger.Error(ex,·null); | 413 | » » » ChatController.Logger.Error(ex,·null); |
| 406 | » » » this.chatBubblePool.Reclaim(pooledBubble); | 414 | » » » this.chatBubblePool.Reclaim(pooledBubble); |
| 407 | » » } | 415 | » » } |
| Offset 427, 33 lines modified | Offset 435, 33 lines modified | ||
| 427 | » » catch·(Exception·ex) | 435 | » » catch·(Exception·ex) |
| 428 | » » { | 436 | » » { |
| 429 | » » » ChatController.Logger.Error(ex,·null); | 437 | » » » ChatController.Logger.Error(ex,·null); |
| 430 | » » » this.chatBubblePool.Reclaim(pooledBubble); | 438 | » » » this.chatBubblePool.Reclaim(pooledBubble); |
| 431 | » » } | 439 | » » } |
| 432 | » } | 440 | » } |
| 433 | 441 | ||
| 434 | » private·void·SetChatBubbleName(ChatBubble·bubble,· | 442 | » private·void·SetChatBubbleName(ChatBubble·bubble,·NetworkedPlayerInfo·playerInfo,·bool·isDead,·bool·didVote,·Color·nameColor,·ChatController.GetFormattedNameFunc·getFormattedNameFunc·=·null) |
| 435 | » { | 443 | » { |
| 436 | » » if·(!string.IsNullOrEmpty(playerInfo.PlayerName)) | 444 | » » if·(!string.IsNullOrEmpty(playerInfo.PlayerName)) |
| 437 | » » { | 445 | » » { |
| Max diff block lines reached; 3090/7865 bytes (39.29%) of diff not shown. | |||
| Offset 266, 29 lines modified | Offset 266, 29 lines modified | ||
| 266 | 266 | ||
| 267 | » [SerializeField] | 267 | » [SerializeField] |
| 268 | » private·GameObject·chard; | 268 | » private·GameObject·chard; |
| 269 | 269 | ||
| 270 | » [SerializeField] | 270 | » [SerializeField] |
| 271 | » private·GameObject·curls; | 271 | » private·GameObject·curls; |
| 272 | 272 | ||
| 273 | » [Header("Navigation")] | ||
| 274 | » [SerializeField] | 273 | » [SerializeField] |
| 274 | » [Header("Navigation")] | ||
| 275 | » private·CollectableVegetable·neighborUp; | 275 | » private·CollectableVegetable·neighborUp; |
| 276 | 276 | ||
| 277 | » [SerializeField] | 277 | » [SerializeField] |
| 278 | » private·CollectableVegetable·neighborDown; | 278 | » private·CollectableVegetable·neighborDown; |
| 279 | 279 | ||
| 280 | » [SerializeField] | 280 | » [SerializeField] |
| 281 | » private·CollectableVegetable·neighborLeft; | 281 | » private·CollectableVegetable·neighborLeft; |
| 282 | 282 | ||
| 283 | » [SerializeField] | 283 | » [SerializeField] |
| 284 | » private·CollectableVegetable·neighborRight; | 284 | » private·CollectableVegetable·neighborRight; |
| 285 | 285 | ||
| 286 | » [Header("Visuals")] | ||
| 287 | » [SerializeField] | 286 | » [SerializeField] |
| 287 | » [Header("Visuals")] | ||
| 288 | » private·GameObject·vegetableContainer; | 288 | » private·GameObject·vegetableContainer; |
| 289 | 289 | ||
| 290 | » [SerializeField] | 290 | » [SerializeField] |
| 291 | » private·Collider2D·collider; | 291 | » private·Collider2D·collider; |
| 292 | 292 | ||
| 293 | » [SerializeField] | 293 | » [SerializeField] |
| 294 | » private·GameObject·selectionGlyph; | 294 | » private·GameObject·selectionGlyph; |
| Offset 153, 16 lines modified | Offset 153, 16 lines modified | ||
| 153 | 153 | ||
| 154 | » [SerializeField] | 154 | » [SerializeField] |
| 155 | » private·GameObject·controllerCursor; | 155 | » private·GameObject·controllerCursor; |
| 156 | 156 | ||
| 157 | » [SerializeField] | 157 | » [SerializeField] |
| 158 | » private·GameObject·handWipeObject; | 158 | » private·GameObject·handWipeObject; |
| 159 | 159 | ||
| 160 | » [Header("Audio")] | ||
| 161 | » [SerializeField] | 160 | » [SerializeField] |
| 161 | » [Header("Audio")] | ||
| 162 | » private·AudioClip[]·dustSounds; | 162 | » private·AudioClip[]·dustSounds; |
| 163 | 163 | ||
| 164 | » private·List<CollectableShell>·shells·=·new·List<CollectableShell>(); | 164 | » private·List<CollectableShell>·shells·=·new·List<CollectableShell>(); |
| 165 | 165 | ||
| 166 | » private·Controller·controller·=·new·Controller(); | 166 | » private·Controller·controller·=·new·Controller(); |
| 167 | 167 | ||
| 168 | » private·Vector2·prevMousePos; | 168 | » private·Vector2·prevMousePos; |
| Offset 71, 20 lines modified | Offset 71, 20 lines modified | ||
| 71 | » » » yield·return·Effects.Wait(0.5f); | 71 | » » » yield·return·Effects.Wait(0.5f); |
| 72 | » » » base.transform.parent.GetComponent<MultistageMinigame>().Close(); | 72 | » » » base.transform.parent.GetComponent<MultistageMinigame>().Close(); |
| 73 | » » } | 73 | » » } |
| 74 | » » yield·return·null; | 74 | » » yield·return·null; |
| 75 | » » yield·break; | 75 | » » yield·break; |
| 76 | » } | 76 | » } |
| 77 | 77 | ||
| 78 | » [SerializeField] | ||
| 79 | » [Header("Design")] | 78 | » [Header("Design")] |
| 79 | » [SerializeField] | ||
| 80 | » private·float·navigationDelay·=·0.2f; | 80 | » private·float·navigationDelay·=·0.2f; |
| 81 | 81 | ||
| 82 | » [SerializeField] | ||
| 83 | » [Header("Components")] | 82 | » [Header("Components")] |
| 83 | » [SerializeField] | ||
| 84 | » private·CollectableVegetable[]·collectables; | 84 | » private·CollectableVegetable[]·collectables; |
| 85 | 85 | ||
| 86 | » [SerializeField] | 86 | » [SerializeField] |
| 87 | » private·AudioClip·selectionChangedSfx; | 87 | » private·AudioClip·selectionChangedSfx; |
| 88 | 88 | ||
| 89 | » private·int·selection; | 89 | » private·int·selection; |
| 90 | 90 | ||
| Offset 34, 15 lines modified | Offset 34, 15 lines modified | ||
| 34 | » » { | 34 | » » { |
| 35 | » » » this.Image.material.SetFloat("_Outline",·(float)(on·?·1·:·0)); | 35 | » » » this.Image.material.SetFloat("_Outline",·(float)(on·?·1·:·0)); |
| 36 | » » » this.Image.material.SetColor("_OutlineColor",·Color.yellow); | 36 | » » » this.Image.material.SetColor("_OutlineColor",·Color.yellow); |
| 37 | » » » this.Image.material.SetColor("_AddColor",·mainTarget·?·Color.yellow·:·Color.clear); | 37 | » » » this.Image.material.SetColor("_AddColor",·mainTarget·?·Color.yellow·:·Color.clear); |
| 38 | » » } | 38 | » » } |
| 39 | » } | 39 | » } |
| 40 | 40 | ||
| 41 | » public·float·CanUse( | 41 | » public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse) |
| 42 | » { | 42 | » { |
| 43 | » » float·num·=·float.MaxValue; | 43 | » » float·num·=·float.MaxValue; |
| 44 | » » PlayerControl·@object·=·pc.Object; | 44 | » » PlayerControl·@object·=·pc.Object; |
| 45 | » » Vector2·truePosition·=·@object.GetTruePosition(); | 45 | » » Vector2·truePosition·=·@object.GetTruePosition(); |
| 46 | » » Vector3·position·=·base.transform.position; | 46 | » » Vector3·position·=·base.transform.position; |
| 47 | » » couldUse·=·(!pc.IsDead·||·(GameManager.Instance.LogicOptions.GetGhostsDoTasks()·&&·!this.GhostsIgnored))·&&·@object.CanMove·&&·pc.Role.CanUse(this)·&&·(!this.onlySameRoom·||·this.InRoom(truePosition))·&&·(!this.onlyFromBelow·||·truePosition.y·<·position.y)·&&·this.FindTask(@object); | 47 | » » couldUse·=·(!pc.IsDead·||·(GameManager.Instance.LogicOptions.GetGhostsDoTasks()·&&·!this.GhostsIgnored))·&&·@object.CanMove·&&·pc.Role.CanUse(this)·&&·(!this.onlySameRoom·||·this.InRoom(truePosition))·&&·(!this.onlyFromBelow·||·truePosition.y·<·position.y)·&&·this.FindTask(@object); |
| 48 | » » canUse·=·couldUse; | 48 | » » canUse·=·couldUse; |
| Offset 17, 15 lines modified | Offset 17, 15 lines modified | ||
| 17 | » public·static·void·SetMainThread() | 17 | » public·static·void·SetMainThread() |
| 18 | » { | 18 | » { |
| 19 | » » Constants._MainThread·=·Thread.CurrentThread; | 19 | » » Constants._MainThread·=·Thread.CurrentThread; |
| 20 | » } | 20 | » } |
| 21 | 21 | ||
| 22 | » internal·static·int·GetBroadcastVersion() | 22 | » internal·static·int·GetBroadcastVersion() |
| 23 | » { | 23 | » { |
| 24 | » » return·5060 | 24 | » » return·50607250; |
| 25 | » } | 25 | » } |
| 26 | 26 | ||
| 27 | » internal·static·bool·IsVersionModded() | 27 | » internal·static·bool·IsVersionModded() |
| 28 | » { | 28 | » { |
| 29 | » » int·broadcastVersion·=·Constants.GetBroadcastVersion(); | 29 | » » int·broadcastVersion·=·Constants.GetBroadcastVersion(); |
| 30 | » » return·broadcastVersion·==·Constants.MODDER_VERSION·||·Constants.GetVersionComponents(broadcastVersion).Item4·>=·25; | 30 | » » return·broadcastVersion·==·Constants.MODDER_VERSION·||·Constants.GetVersionComponents(broadcastVersion).Item4·>=·25; |
| 31 | » } | 31 | » } |
| Offset 180, 27 lines modified | Offset 180, 27 lines modified | ||
| 180 | 180 | ||
| 181 | » public·static·CultureInfo·CultureInfo·=·CultureInfo.CreateSpecificCulture("en-US"); | 181 | » public·static·CultureInfo·CultureInfo·=·CultureInfo.CreateSpecificCulture("en-US"); |
| 182 | 182 | ||
| 183 | » public·static·readonly·int[]·CompatVersions·=·new·int[]·{·Constants.GetBroadcastVersion()·}; | 183 | » public·static·readonly·int[]·CompatVersions·=·new·int[]·{·Constants.GetBroadcastVersion()·}; |
| 184 | 184 | ||
| 185 | » public·const·int·Year·=·2024; | 185 | » public·const·int·Year·=·2024; |
| 186 | 186 | ||
| 187 | » public·const·int·Month·=· | 187 | » public·const·int·Month·=·4; |
| 188 | 188 | ||
| 189 | » public·const·int·Day·=· | 189 | » public·const·int·Day·=·1; |
| 190 | 190 | ||
| 191 | » public·const·int·Revision·=·0; | 191 | » public·const·int·Revision·=·0; |
| 192 | 192 | ||
| 193 | » public·const·int·VisualRevision·=·0; | 193 | » public·const·int·VisualRevision·=·0; |
| 194 | 194 | ||
| 195 | » public·const·string·AddressablesVersion·=·"2024_3_20_1015"; | 195 | » public·const·string·AddressablesVersion·=·"2024_3_20_1015"; |
| 196 | 196 | ||
| 197 | » public·const·string·extraBuildVersionInfo·=·"(build·num:·4 | 197 | » public·const·string·extraBuildVersionInfo·=·"(build·num:·4431)"; |
| 198 | 198 | ||
| 199 | » public·const·int·pipelineBuildNumber·=·4 | 199 | » public·const·int·pipelineBuildNumber·=·4431; |
| 200 | 200 | ||
| 201 | » public·const·BuildEnvironment·environment·=·BuildEnvironment.Production; | 201 | » public·const·BuildEnvironment·environment·=·BuildEnvironment.Production; |
| 202 | 202 | ||
| 203 | » public·const·byte·EmptyPlayerID·=·255; | 203 | » public·const·byte·EmptyPlayerID·=·255; |
| 204 | 204 | ||
| 205 | » private·static·Thread·_MainThread; | 205 | » private·static·Thread·_MainThread; |
| 206 | 206 | ||
| Offset 21, 14 lines modified | Offset 21, 18 lines modified | ||
| 21 | » { | 21 | » { |
| 22 | » » if·(this.player.GetButtonDown((int)this.Action)) | 22 | » » if·(this.player.GetButtonDown((int)this.Action)) |
| 23 | » » { | 23 | » » { |
| 24 | » » » if·(this.requiredMenuNames.Count·>·0·&&·!this.requiredMenuNames.Contains(ControllerManager.Instance.CurrentUiState.MenuName)) | 24 | » » » if·(this.requiredMenuNames.Count·>·0·&&·!this.requiredMenuNames.Contains(ControllerManager.Instance.CurrentUiState.MenuName)) |
| 25 | » » » { | 25 | » » » { |
| 26 | » » » » return; | 26 | » » » » return; |
| 27 | » » » } | 27 | » » » } |
| 28 | » » » if·(this.restrictedMenuNames.Count·>·0·&&·this.restrictedMenuNames.Contains(ControllerManager.Instance.CurrentUiState.MenuName)) | ||
| 29 | » » » { | ||
| 30 | » » » » return; | ||
| 31 | » » » } | ||
| 28 | » » » Action·onPressedEvent·=·this.OnPressedEvent; | 32 | » » » Action·onPressedEvent·=·this.OnPressedEvent; |
| 29 | » » » if·(onPressedEvent·!=·null) | 33 | » » » if·(onPressedEvent·!=·null) |
| 30 | » » » { | 34 | » » » { |
| 31 | » » » » onPressedEvent(); | 35 | » » » » onPressedEvent(); |
| 32 | » » » } | 36 | » » » } |
| 33 | » » » ButtonBehavior·component·=·base.GetComponent<ButtonBehavior>(); | 37 | » » » ButtonBehavior·component·=·base.GetComponent<ButtonBehavior>(); |
| 34 | » » » if·(component) | 38 | » » » if·(component) |
| Offset 59, 9 lines modified | Offset 63, 11 lines modified | ||
| 59 | 63 | ||
| 60 | » public·RewiredConstsEnum.Action·Action; | 64 | » public·RewiredConstsEnum.Action·Action; |
| 61 | 65 | ||
| 62 | » public·GameObject·requiredMenuObject; | 66 | » public·GameObject·requiredMenuObject; |
| 63 | 67 | ||
| 64 | » public·List<string>·requiredMenuNames·=·new·List<string>(); | 68 | » public·List<string>·requiredMenuNames·=·new·List<string>(); |
| 65 | 69 | ||
| 70 | » public·List<string>·restrictedMenuNames·=·new·List<string>(); | ||
| 71 | |||
| 66 | » private·Player·player; | 72 | » private·Player·player; |
| 67 | } | 73 | } |
| Offset 560, 14 lines modified | Offset 560, 22 lines modified | ||
| 560 | » » » » ButtonBehavior·buttonBehavior2·=·this.CurrentUiState.CurrentSelection·as·ButtonBehavior; | 560 | » » » » ButtonBehavior·buttonBehavior2·=·this.CurrentUiState.CurrentSelection·as·ButtonBehavior; |
| 561 | » » » » if·(buttonBehavior2·!=·null·&&·buttonBehavior2.isActiveAndEnabled) | 561 | » » » » if·(buttonBehavior2·!=·null·&&·buttonBehavior2.isActiveAndEnabled) |
| 562 | » » » » { | 562 | » » » » { |
| 563 | » » » » » buttonBehavior2.ReceiveClick(); | 563 | » » » » » buttonBehavior2.ReceiveClick(); |
| 564 | » » » » } | 564 | » » » » } |
| 565 | » » » } | 565 | » » » } |
| 566 | » » } | 566 | » » } |
| 567 | » » else·if·(this.IsButtonHeld) | ||
| 568 | » » { | ||
| 569 | » » » PassiveUiElement·passiveUiElement3·=·this.CurrentUiState.CurrentSelection·as·PassiveUiElement; | ||
| 570 | » » » if·(passiveUiElement3·!=·null·&&·passiveUiElement3.isActiveAndEnabled·&&·passiveUiElement3.HandleRepeat) | ||
| 571 | » » » { | ||
| 572 | » » » » passiveUiElement3.ReceiveRepeatDown(); | ||
| 573 | » » » } | ||
| 574 | » » } | ||
| 567 | » » this.deltaSinceLastUiHighlight·+=·Time.deltaTime; | 575 | » » this.deltaSinceLastUiHighlight·+=·Time.deltaTime; |
| 568 | » » bool·flag·=·false; | 576 | » » bool·flag·=·false; |
| 569 | » » bool·buttonDown·=·this.player.GetButtonDown(25); | 577 | » » bool·buttonDown·=·this.player.GetButtonDown(25); |
| 570 | » » bool·buttonDown2·=·this.player.GetButtonDown(26); | 578 | » » bool·buttonDown2·=·this.player.GetButtonDown(26); |
| 571 | » » bool·buttonDown3·=·this.player.GetButtonDown(27); | 579 | » » bool·buttonDown3·=·this.player.GetButtonDown(27); |
| 572 | » » bool·buttonDown4·=·this.player.GetButtonDown(28); | 580 | » » bool·buttonDown4·=·this.player.GetButtonDown(28); |
| 573 | » » float·num·=·0f; | 581 | » » float·num·=·0f; |
| Offset 603, 18 lines modified | Offset 611, 18 lines modified | ||
| 603 | » » » » » return; | 611 | » » » » » return; |
| 604 | » » » » } | 612 | » » » » } |
| 605 | » » » } | 613 | » » » } |
| 606 | » » » if·(this.deltaSinceLastUiHighlight·>·0.25f·||·!this.inputDetectedLastFrame·||·flag) | 614 | » » » if·(this.deltaSinceLastUiHighlight·>·0.25f·||·!this.inputDetectedLastFrame·||·flag) |
| 607 | » » » { | 615 | » » » { |
| 608 | » » » » UiElement·uiElement·=·null; | 616 | » » » » UiElement·uiElement·=·null; |
| 609 | » » » » Vector2·vector·=·this.CurrentUiState.CurrentSelection.transform.position; | 617 | » » » » Vector2·vector·=·this.CurrentUiState.CurrentSelection.transform.position; |
| 610 | » » » » PassiveUiElement·passiveUiElement | 618 | » » » » PassiveUiElement·passiveUiElement4·=·this.CurrentUiState.CurrentSelection·as·PassiveUiElement; |
| 611 | » » » » if·(passiveUiElement | 619 | » » » » if·(passiveUiElement4·!=·null·&&·passiveUiElement4.Colliders.Length·!=·0) |
| 612 | » » » » { | 620 | » » » » { |
| 613 | » » » » » vector·=·passiveUiElement | 621 | » » » » » vector·=·passiveUiElement4.Colliders[0].bounds.center; |
| 614 | » » » » } | 622 | » » » » } |
| 615 | » » » » Vector2·vector2·=·new·Vector3(num,·num2); | 623 | » » » » Vector2·vector2·=·new·Vector3(num,·num2); |
| 616 | » » » » if·(this.CurrentUiState.CurrentSelection.ControllerNav.mode·==·ControllerNavigation.Mode.Explicit) | 624 | » » » » if·(this.CurrentUiState.CurrentSelection.ControllerNav.mode·==·ControllerNavigation.Mode.Explicit) |
| 617 | » » » » { | 625 | » » » » { |
| 618 | » » » » » AxisDirection·axisDirection·=·this.FindClosestDirection(vector2); | 626 | » » » » » AxisDirection·axisDirection·=·this.FindClosestDirection(vector2); |
| 619 | » » » » » uiElement·=·this.FindUiElementByExplicitNavigation(this.CurrentUiState.CurrentSelection,·this.CurrentUiState.CurrentSelection,·axisDirection); | 627 | » » » » » uiElement·=·this.FindUiElementByExplicitNavigation(this.CurrentUiState.CurrentSelection,·this.CurrentUiState.CurrentSelection,·axisDirection); |
| 620 | » » » » } | 628 | » » » » } |
| Offset 952, 15 lines modified | Offset 960, 15 lines modified | ||
| 952 | » » » if·(DestroyableSingleton<PassiveButtonManager>.InstanceExists) | 960 | » » » if·(DestroyableSingleton<PassiveButtonManager>.InstanceExists) |
| 953 | » » » { | 961 | » » » { |
| 954 | » » » » DestroyableSingleton<PassiveButtonManager>.Instance.LoseFocusForAll(); | 962 | » » » » DestroyableSingleton<PassiveButtonManager>.Instance.LoseFocusForAll(); |
| 955 | » » » } | 963 | » » » } |
| 956 | » » » if·(ActiveInputManager.currentControlType·==·ActiveInputManager.InputType.Joystick) | 964 | » » » if·(ActiveInputManager.currentControlType·==·ActiveInputManager.InputType.Joystick) |
| 957 | » » » { | 965 | » » » { |
| 958 | » » » » selection.ReceiveMouseOver(); | 966 | » » » » selection.ReceiveMouseOver(); |
| 959 | » » » » if·(selection.GetComponent<ColorChip>()·||·selection.GetComponent<AnnouncementPanel>()) | 967 | » » » » if·(selection.GetComponent<ColorChip>()·||·selection.GetComponent<AnnouncementPanel>()·||·selection.GetComponent<ViewSettingsTabButton>()) |
| 960 | » » » » { | 968 | » » » » { |
| 961 | » » » » » (selection·as·PassiveButton).OnClick.Invoke(); | 969 | » » » » » (selection·as·PassiveButton).OnClick.Invoke(); |
| 962 | » » » » } | 970 | » » » » } |
| 963 | » » » } | 971 | » » » } |
| 964 | » » » this.CurrentUiState.CurrentSelection·=·selection; | 972 | » » » this.CurrentUiState.CurrentSelection·=·selection; |
| 965 | » » » this.deltaSinceLastUiHighlight·=·0f; | 973 | » » » this.deltaSinceLastUiHighlight·=·0f; |
| 966 | » » » return; | 974 | » » » return; |
| Offset 127, 16 lines modified | Offset 127, 16 lines modified | ||
| 127 | 127 | ||
| 128 | » [SerializeField] | 128 | » [SerializeField] |
| 129 | » private·Sprite·cookedFish; | 129 | » private·Sprite·cookedFish; |
| 130 | 130 | ||
| 131 | » [SerializeField] | 131 | » [SerializeField] |
| 132 | » private·GameObject·glyphActionGO; | 132 | » private·GameObject·glyphActionGO; |
| 133 | 133 | ||
| 134 | » [Header("Audio")] | ||
| 135 | » [SerializeField] | 134 | » [SerializeField] |
| 135 | » [Header("Audio")] | ||
| 136 | » private·AudioClip·onGrillSfx; | 136 | » private·AudioClip·onGrillSfx; |
| 137 | 137 | ||
| 138 | » [SerializeField] | 138 | » [SerializeField] |
| 139 | » private·AudioClip·onFlipSfx; | 139 | » private·AudioClip·onFlipSfx; |
| 140 | 140 | ||
| 141 | » [SerializeField] | 141 | » [SerializeField] |
| 142 | » private·AudioClip·onFinishCookingSfx; | 142 | » private·AudioClip·onFinishCookingSfx; |
| Offset 1, 12 lines modified | Offset 1, 13 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections; | 2 | using·System.Collections; |
| 3 | using·System.Collections.Generic; | 3 | using·System.Collections.Generic; |
| 4 | using·Innersloth.Assets; | 4 | using·Innersloth.Assets; |
| 5 | using·UnityEngine; | 5 | using·UnityEngine; |
| 6 | using·UnityEngine.AddressableAssets; | ||
| 6 | 7 | ||
| 7 | public·class·CosmeticData·:·ScriptableObject,·IBuyable | 8 | public·class·CosmeticData·:·ScriptableObject,·IBuyable |
| 8 | { | 9 | { |
| 9 | » public·string·ProdId | 10 | » public·string·ProdId |
| 10 | » { | 11 | » { |
| 11 | » » get | 12 | » » get |
| 12 | » » { | 13 | » » { |
| Offset 76, 23 lines modified | Offset 77, 50 lines modified | ||
| 76 | » public·virtual·IEnumerator·CoLoadIcon(Action<Sprite,·AddressableAsset>·onLoaded) | 77 | » public·virtual·IEnumerator·CoLoadIcon(Action<Sprite,·AddressableAsset>·onLoaded) |
| 77 | » { | 78 | » { |
| 78 | » » yield·return·null; | 79 | » » yield·return·null; |
| 79 | » » onLoaded(null,·null); | 80 | » » onLoaded(null,·null); |
| 80 | » » yield·break; | 81 | » » yield·break; |
| 81 | » } | 82 | » } |
| 82 | 83 | ||
| 83 | » public·void· | 84 | » public·void·CoLoadPreview(Action<Sprite,·AddressableAsset>·onLoaded) |
| 84 | » { | 85 | » { |
| 85 | » » renderer.sprite·=·this.SpritePreview; | ||
| 86 | » » | 86 | » » Sprite·sprite·=·null; |
| 87 | » » if·(this.PreviewData.RuntimeKeyIsValid()) | ||
| 87 | » » { | 88 | » » { |
| 88 | » » » | 89 | » » » AddressableAsset<PreviewViewData>·asset·=·new·AddressableAsset<PreviewViewData>(this.PreviewData); |
| 90 | » » » asset.LoadAsync(delegate | ||
| 91 | » » » { | ||
| 92 | » » » » PreviewViewData·asset2·=·asset.GetAsset(); | ||
| 93 | » » » » sprite·=·((asset2·!=·null)·?·asset2.PreviewSprite·:·null); | ||
| 94 | » » » » onLoaded(sprite,·asset); | ||
| 95 | » » » },·null,·null); | ||
| 89 | » » } | 96 | » » } |
| 90 | » } | 97 | » } |
| 91 | 98 | ||
| 99 | » public·void·SetPreview(SpriteRenderer·renderer,·int·color) | ||
| 100 | » { | ||
| 101 | » » this.CoLoadPreview(delegate(Sprite·sprite,·AddressableAsset·asset) | ||
| 102 | » » { | ||
| 103 | » » » if·(renderer·!=·null) | ||
| 104 | » » » { | ||
| 105 | » » » » renderer.sprite·=·sprite; | ||
| 106 | » » » » AddressableAssetHandler.AddToGameObject(renderer.gameObject,·asset); | ||
| 107 | » » » » if·(Application.isPlaying) | ||
| 108 | » » » » { | ||
| 109 | » » » » » PlayerMaterial.SetColors(color,·renderer); | ||
| 110 | » » » » » return; | ||
| 111 | » » » » } | ||
| 112 | » » » } | ||
| 113 | » » » else | ||
| 114 | » » » { | ||
| 115 | » » » » asset.Unload(); | ||
| 116 | » » » } | ||
| 117 | » » }); | ||
| 118 | » } | ||
| 119 | |||
| 92 | » public·const·string·TranslationPrefix·=·"Cosmetic."; | 120 | » public·const·string·TranslationPrefix·=·"Cosmetic."; |
| 93 | 121 | ||
| 94 | » public·List<Platforms>·unlockOnSelectPlatforms; | 122 | » public·List<Platforms>·unlockOnSelectPlatforms; |
| 95 | 123 | ||
| 96 | » public·bool·freeRedeemableCosmetic; | 124 | » public·bool·freeRedeemableCosmetic; |
| 97 | 125 | ||
| 98 | » public·int·redeemPopUpColor·=·-1; | 126 | » public·int·redeemPopUpColor·=·-1; |
| Offset 115, 11 lines modified | Offset 143, 11 lines modified | ||
| 115 | 143 | ||
| 116 | » public·int·displayOrder; | 144 | » public·int·displayOrder; |
| 117 | 145 | ||
| 118 | » public·bool·NotInStore; | 146 | » public·bool·NotInStore; |
| 119 | 147 | ||
| 120 | » public·bool·Free; | 148 | » public·bool·Free; |
| 121 | 149 | ||
| 122 | » public· | 150 | » public·AssetReference·PreviewData; |
| 123 | 151 | ||
| 124 | » public·bool·PreviewCrewmateColor; | 152 | » public·bool·PreviewCrewmateColor; |
| 125 | } | 153 | } |
| Offset 25, 19 lines modified | Offset 25, 29 lines modified | ||
| 25 | » } | 25 | » } |
| 26 | 26 | ||
| 27 | » public·bool·TryGetReleaseGroup(CosmeticData·cosmetic,·out·CosmeticReleaseGroup·output) | 27 | » public·bool·TryGetReleaseGroup(CosmeticData·cosmetic,·out·CosmeticReleaseGroup·output) |
| 28 | » { | 28 | » { |
| 29 | » » return·this.TryGetGroup<CosmeticReleaseGroup>(this.releaseGroups,·cosmetic,·out·output); | 29 | » » return·this.TryGetGroup<CosmeticReleaseGroup>(this.releaseGroups,·cosmetic,·out·output); |
| 30 | » } | 30 | » } |
| 31 | 31 | ||
| 32 | » public·int·GetReleaseGroupIndex(CosmeticData·cosmetic) | ||
| 33 | » { | ||
| 34 | » » return·this.GetGroupItemIndex<CosmeticReleaseGroup>(this.releaseGroups,·cosmetic); | ||
| 35 | » } | ||
| 36 | |||
| 37 | » public·int·GetVariantGroupIndex(CosmeticData·cosmetic) | ||
| 38 | » { | ||
| 39 | » » return·this.GetGroupItemIndex<CosmeticVariantGroup>(this.variantGroups,·cosmetic); | ||
| 40 | » } | ||
| 41 | |||
| 32 | » public·DateTime·GetReleaseGroupDate(CosmeticData·cosmetic) | 42 | » public·DateTime·GetReleaseGroupDate(CosmeticData·cosmetic) |
| 33 | » { | 43 | » { |
| 34 | » » foreach·(CosmeticReleaseGroup·cosmeticReleaseGroup·in·this.releaseGroups) | 44 | » » foreach·(CosmeticReleaseGroup·cosmeticReleaseGroup·in·this.releaseGroups) |
| 35 | » » { | 45 | » » { |
| 36 | » » » if·(!string.IsNullOrWhiteSpace(cosmeticReleaseGroup.DateString)·&&·cosmeticReleaseGroup.Contains(cosmetic | 46 | » » » if·(!string.IsNullOrWhiteSpace(cosmeticReleaseGroup.DateString)·&&·cosmeticReleaseGroup.Contains(cosmetic)) |
| 37 | » » » { | 47 | » » » { |
| 38 | » » » » return·Constants.ParseDate(cosmeticReleaseGroup.DateString); | 48 | » » » » return·Constants.ParseDate(cosmeticReleaseGroup.DateString); |
| 39 | » » » } | 49 | » » » } |
| 40 | » » } | 50 | » » } |
| 41 | » » return·DateTime.MinValue; | 51 | » » return·DateTime.MinValue; |
| 42 | » } | 52 | » } |
| 43 | 53 | ||
| Offset 51, 14 lines modified | Offset 61, 30 lines modified | ||
| 51 | » » » » return·true; | 61 | » » » » return·true; |
| 52 | » » » } | 62 | » » » } |
| 53 | » » } | 63 | » » } |
| 54 | » » output·=·default(T); | 64 | » » output·=·default(T); |
| 55 | » » return·false; | 65 | » » return·false; |
| 56 | » } | 66 | » } |
| 57 | 67 | ||
| 68 | » private·int·GetGroupItemIndex<T>(T[]·groups,·CosmeticData·cosmetic)·where·T·:·AbstractCosmeticGroup | ||
| 69 | » { | ||
| 70 | » » foreach·(T·t·in·groups) | ||
| 71 | » » { | ||
| 72 | » » » if·(t.Contains(cosmetic)) | ||
| 73 | » » » { | ||
| 74 | » » » » int·num·=·t.IndexOf(cosmetic); | ||
| 75 | » » » » if·(num·>=·0) | ||
| 76 | » » » » { | ||
| 77 | » » » » » return·num; | ||
| 78 | » » » » } | ||
| 79 | » » » } | ||
| 80 | » » } | ||
| 81 | » » return·int.MaxValue; | ||
| 82 | » } | ||
| 83 | |||
| 58 | » public·void·RebuildGroups(CosmeticVariantGroup[]·variantGroups,·CosmeticReleaseGroup[]·releaseGroups) | 84 | » public·void·RebuildGroups(CosmeticVariantGroup[]·variantGroups,·CosmeticReleaseGroup[]·releaseGroups) |
| 59 | » { | 85 | » { |
| 60 | » » this.variantGroups·=·variantGroups; | 86 | » » this.variantGroups·=·variantGroups; |
| 61 | » » this.releaseGroups·=·releaseGroups; | 87 | » » this.releaseGroups·=·releaseGroups; |
| 62 | » } | 88 | » } |
| 63 | 89 | ||
| 64 | » [SerializeField] | 90 | » [SerializeField] |
| Offset 24, 15 lines modified | Offset 24, 15 lines modified | ||
| 24 | » » HashSet<string>·hashSet6·=·new·HashSet<string>(); | 24 | » » HashSet<string>·hashSet6·=·new·HashSet<string>(); |
| 25 | » » hashSet6.Add("pet_EmptyPet"); | 25 | » » hashSet6.Add("pet_EmptyPet"); |
| 26 | » » HashSet<string>·petIds·=·hashSet6; | 26 | » » HashSet<string>·petIds·=·hashSet6; |
| 27 | » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) | 27 | » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) |
| 28 | » » { | 28 | » » { |
| 29 | » » » if·(!(playerControl·==·null)·&&·playerControl.CurrentOutfit·!=·null·&&·!(playerControl.gameObject·==·null)) | 29 | » » » if·(!(playerControl·==·null)·&&·playerControl.CurrentOutfit·!=·null·&&·!(playerControl.gameObject·==·null)) |
| 30 | » » » { | 30 | » » » { |
| 31 | » » » » | 31 | » » » » NetworkedPlayerInfo.PlayerOutfit·currentOutfit·=·playerControl.CurrentOutfit; |
| 32 | » » » » hashSet2.Add(currentOutfit.HatId); | 32 | » » » » hashSet2.Add(currentOutfit.HatId); |
| 33 | » » » » skinIds.Add(currentOutfit.SkinId); | 33 | » » » » skinIds.Add(currentOutfit.SkinId); |
| 34 | » » » » visorIds.Add(currentOutfit.VisorId); | 34 | » » » » visorIds.Add(currentOutfit.VisorId); |
| 35 | » » » » namePlateIds.Add(currentOutfit.NamePlateId); | 35 | » » » » namePlateIds.Add(currentOutfit.NamePlateId); |
| 36 | » » » » petIds.Add(currentOutfit.PetId); | 36 | » » » » petIds.Add(currentOutfit.PetId); |
| 37 | » » » } | 37 | » » » } |
| 38 | » » } | 38 | » » } |
| Offset 253, 15 lines modified | Offset 253, 15 lines modified | ||
| 253 | » » if·(addressableAssetGroup·==·null) | 253 | » » if·(addressableAssetGroup·==·null) |
| 254 | » » { | 254 | » » { |
| 255 | » » » return; | 255 | » » » return; |
| 256 | » » } | 256 | » » } |
| 257 | » » addressableAssetGroup.Destroy(); | 257 | » » addressableAssetGroup.Destroy(); |
| 258 | » } | 258 | » } |
| 259 | 259 | ||
| 260 | » public·IEnumerator·CoPopulateFromOutfit( | 260 | » public·IEnumerator·CoPopulateFromOutfit(NetworkedPlayerInfo.PlayerOutfit·outfit) |
| 261 | » { | 261 | » { |
| 262 | » » yield·return·this.CoAddHat(outfit.HatId); | 262 | » » yield·return·this.CoAddHat(outfit.HatId); |
| 263 | » » yield·return·this.CoAddVisor(outfit.VisorId); | 263 | » » yield·return·this.CoAddVisor(outfit.VisorId); |
| 264 | » » yield·return·this.CoAddSkin(outfit.SkinId); | 264 | » » yield·return·this.CoAddSkin(outfit.SkinId); |
| 265 | » » yield·return·this.CoAddPet(outfit.PetId); | 265 | » » yield·return·this.CoAddPet(outfit.PetId); |
| 266 | » » yield·return·this.CoAddNameplate(outfit.NamePlateId); | 266 | » » yield·return·this.CoAddNameplate(outfit.NamePlateId); |
| 267 | » » yield·break; | 267 | » » yield·break; |
| Offset 145, 14 lines modified | Offset 145, 33 lines modified | ||
| 145 | » » if·(this.currentPet) | 145 | » » if·(this.currentPet) |
| 146 | » » { | 146 | » » { |
| 147 | » » » this.currentPet.Visible·=·this.visible; | 147 | » » » this.currentPet.Visible·=·this.visible; |
| 148 | » » } | 148 | » » } |
| 149 | » » this.UpdateNameVisibility(); | 149 | » » this.UpdateNameVisibility(); |
| 150 | » } | 150 | » } |
| 151 | 151 | ||
| 152 | » public·void·SetPhantomRoleAlpha(float·alphaValue) | ||
| 153 | » { | ||
| 154 | » » this.currentBodySprite.BodySprite.color·=·this.currentBodySprite.BodySprite.color.SetAlpha(alphaValue); | ||
| 155 | » » this.skin.layer.color·=·this.skin.layer.color.SetAlpha(alphaValue); | ||
| 156 | » » this.hat.FrontLayer.color·=·this.hat.FrontLayer.color.SetAlpha(alphaValue); | ||
| 157 | » » this.hat.BackLayer.color·=·this.hat.BackLayer.color.SetAlpha(alphaValue); | ||
| 158 | » » this.visor.Alpha·=·alphaValue; | ||
| 159 | » » if·(this.currentPet·!=·null) | ||
| 160 | » » { | ||
| 161 | » » » this.currentPet.SetAlpha(alphaValue); | ||
| 162 | » » » this.PettingHand.SetAlpha(alphaValue); | ||
| 163 | » » } | ||
| 164 | » } | ||
| 165 | |||
| 166 | » public·float·GetPhantomRoleAlpha() | ||
| 167 | » { | ||
| 168 | » » return·this.currentBodySprite.BodySprite.color.a; | ||
| 169 | » } | ||
| 170 | |||
| 152 | » public·void·SetPetVisible(bool·v) | 171 | » public·void·SetPetVisible(bool·v) |
| 153 | » { | 172 | » { |
| 154 | » » if·(this.currentPet) | 173 | » » if·(this.currentPet) |
| 155 | » » { | 174 | » » { |
| 156 | » » » this.currentPet.Visible·=·v; | 175 | » » » this.currentPet.Visible·=·v; |
| 157 | » » } | 176 | » » } |
| 158 | » } | 177 | » } |
| Offset 251, 14 lines modified | Offset 270, 19 lines modified | ||
| 251 | » { | 270 | » { |
| 252 | » » if·(this.visor) | 271 | » » if·(this.visor) |
| 253 | » » { | 272 | » » { |
| 254 | » » » this.visor.transform.localPosition·=·pos; | 273 | » » » this.visor.transform.localPosition·=·pos; |
| 255 | » » } | 274 | » » } |
| 256 | » } | 275 | » } |
| 257 | 276 | ||
| 277 | » public·SkinViewData·GetSkinView() | ||
| 278 | » { | ||
| 279 | » » return·this.skin.skin; | ||
| 280 | » } | ||
| 281 | |||
| 258 | » public·void·FixSkinSprite(Sprite·skinSprite) | 282 | » public·void·FixSkinSprite(Sprite·skinSprite) |
| 259 | » { | 283 | » { |
| 260 | » » this.skin.animator.Stop(); | 284 | » » this.skin.animator.Stop(); |
| 261 | » » this.skin.layer.sprite·=·skinSprite; | 285 | » » this.skin.layer.sprite·=·skinSprite; |
| 262 | » } | 286 | » } |
| 263 | 287 | ||
| 264 | » public·PetBehaviour·GetPet() | 288 | » public·PetBehaviour·GetPet() |
| Offset 567, 21 lines modified | Offset 591, 35 lines modified | ||
| 567 | » { | 591 | » { |
| 568 | » » this.visor.gameObject.SetActive(active); | 592 | » » this.visor.gameObject.SetActive(active); |
| 569 | » } | 593 | » } |
| 570 | 594 | ||
| 571 | » public·void·SetHatAndVisorIdle(int·colorId) | 595 | » public·void·SetHatAndVisorIdle(int·colorId) |
| 572 | » { | 596 | » { |
| 573 | » » this.hat.SetIdleAnim(colorId); | 597 | » » this.hat.SetIdleAnim(colorId); |
| 598 | » » if·(this.visor.isActiveAndEnabled) | ||
| 599 | » » { | ||
| 600 | » » » this.visor.SetIdleAnim(colorId); | ||
| 601 | » » » return; | ||
| 602 | » » } | ||
| 574 | » » this.ToggleVisor(true); | 603 | » » this.ToggleVisor(true); |
| 575 | » } | 604 | » } |
| 576 | 605 | ||
| 606 | » public·void·SetHatLeftFacingVictim(bool·leftFacingVictim) | ||
| 607 | » { | ||
| 608 | » » this.hat.SetShouldFaceLeft(leftFacingVictim); | ||
| 609 | » } | ||
| 610 | |||
| 577 | » public·void·SetHat | 611 | » public·void·SetHatOnFloor() |
| 578 | » { | 612 | » { |
| 579 | » » this.hat.SetFloorAnim(); | 613 | » » this.hat.SetFloorAnim(); |
| 614 | » } | ||
| 615 | |||
| 616 | » public·void·SetVisorOnFloor() | ||
| 617 | » { | ||
| 580 | » » this. | 618 | » » this.visor.SetFloorAnim(); |
| 581 | » } | 619 | » } |
| 582 | 620 | ||
| 583 | » public·void·SetHatAndVisorMaskType(PlayerMaterial.MaskType·type) | 621 | » public·void·SetHatAndVisorMaskType(PlayerMaterial.MaskType·type) |
| 584 | » { | 622 | » { |
| 585 | » » this.hat.SetMaskType(type); | 623 | » » this.hat.SetMaskType(type); |
| 586 | » » this.visor.SetMaskType(type); | 624 | » » this.visor.SetMaskType(type); |
| 587 | » } | 625 | » } |
| Offset 1128, 14 lines modified | Offset 1166, 15 lines modified | ||
| 1128 | » » this.skin.UnloadAddressableAsset(asset); | 1166 | » » this.skin.UnloadAddressableAsset(asset); |
| 1129 | » } | 1167 | » } |
| 1130 | 1168 | ||
| 1131 | » public·void·AnimateClimb(bool·down) | 1169 | » public·void·AnimateClimb(bool·down) |
| 1132 | » { | 1170 | » { |
| 1133 | » » this.skin.SetClimb(down); | 1171 | » » this.skin.SetClimb(down); |
| 1134 | » » this.hat.SetClimbAnim(); | 1172 | » » this.hat.SetClimbAnim(); |
| 1173 | » » this.visor.SetClimbAnim(this.bodyType); | ||
| 1135 | » } | 1174 | » } |
| 1136 | 1175 | ||
| 1137 | » public·void·AnimatePetMourning() | 1176 | » public·void·AnimatePetMourning() |
| 1138 | » { | 1177 | » { |
| 1139 | » » if·(this.currentPet) | 1178 | » » if·(this.currentPet) |
| 1140 | » » { | 1179 | » » { |
| 1141 | » » » this.currentPet.SetMourning(); | 1180 | » » » this.currentPet.SetMourning(); |
| Offset 137, 15 lines modified | Offset 137, 15 lines modified | ||
| 137 | » public·void·SetPositionAndScale(UnlockableCosmetic·cosmetic) | 137 | » public·void·SetPositionAndScale(UnlockableCosmetic·cosmetic) |
| 138 | » { | 138 | » { |
| 139 | » » if·(cosmetic.unlockableCosmetic) | 139 | » » if·(cosmetic.unlockableCosmetic) |
| 140 | » » { | 140 | » » { |
| 141 | » » » if·(!(cosmetic.unlockableCosmetic·is·NamePlateData)) | 141 | » » » if·(!(cosmetic.unlockableCosmetic·is·NamePlateData)) |
| 142 | » » » { | 142 | » » » { |
| 143 | » » » » this.icon.transform.localScale·=·new·Vector3(0.6f,·0.6f,·1f); | 143 | » » » » this.icon.transform.localScale·=·new·Vector3(0.6f,·0.6f,·1f); |
| 144 | » » » » this.icon.transform.localPosition·=·new·Vector3( | 144 | » » » » this.icon.transform.localPosition·=·new·Vector3(this.icon.transform.localPosition.x,·this.icon.transform.localPosition.y,·-3f); |
| 145 | » » » » return; | 145 | » » » » return; |
| 146 | » » » } | 146 | » » » } |
| 147 | » » » this.icon.transform.localScale·=·new·Vector3(0.7f,·0.7f,·1f); | 147 | » » » this.icon.transform.localScale·=·new·Vector3(0.7f,·0.7f,·1f); |
| 148 | » » » this.icon.transform.localPosition·=·new·Vector3(-0.65f,·-0.14f,·-3f); | 148 | » » » this.icon.transform.localPosition·=·new·Vector3(-0.65f,·-0.14f,·-3f); |
| 149 | » » } | 149 | » » } |
| 150 | » } | 150 | » } |
| 151 | 151 | ||
| Offset 139, 24 lines modified | Offset 139, 24 lines modified | ||
| 139 | » » return·audioClip; | 139 | » » return·audioClip; |
| 140 | » } | 140 | » } |
| 141 | 141 | ||
| 142 | » private·static·readonly·string·SHADER_Y_PERCENT·=·"_PercentY"; | 142 | » private·static·readonly·string·SHADER_Y_PERCENT·=·"_PercentY"; |
| 143 | 143 | ||
| 144 | » private·static·readonly·string·CRANK_MOTOR_SFX·=·"crankMotorLoop"; | 144 | » private·static·readonly·string·CRANK_MOTOR_SFX·=·"crankMotorLoop"; |
| 145 | 145 | ||
| 146 | » [SerializeField] | ||
| 147 | » [Tooltip("Indicates·how·much·spinning·its·needed·to·complete·task")] | 146 | » [Tooltip("Indicates·how·much·spinning·its·needed·to·complete·task")] |
| 147 | » [SerializeField] | ||
| 148 | » private·float·targetProgress·=·2000f; | 148 | » private·float·targetProgress·=·2000f; |
| 149 | 149 | ||
| 150 | » [SerializeField] | 150 | » [SerializeField] |
| 151 | » [Tooltip("How·fast·does·machine·loses·power·when·not·spinning")] | 151 | » [Tooltip("How·fast·does·machine·loses·power·when·not·spinning")] |
| 152 | » private·float·progressDecay·=·250f; | 152 | » private·float·progressDecay·=·250f; |
| 153 | 153 | ||
| 154 | » [SerializeField] | ||
| 155 | » [Tooltip("CrankAudioPlays·targetprogress/lightbulbRate")] | 154 | » [Tooltip("CrankAudioPlays·targetprogress/lightbulbRate")] |
| 155 | » [SerializeField] | ||
| 156 | » private·int·crankAudioRate; | 156 | » private·int·crankAudioRate; |
| 157 | 157 | ||
| 158 | » [SerializeField] | 158 | » [SerializeField] |
| 159 | » private·SpriteRenderer·powerBarSpriteRenderer; | 159 | » private·SpriteRenderer·powerBarSpriteRenderer; |
| 160 | 160 | ||
| 161 | » [SerializeField] | 161 | » [SerializeField] |
| 162 | » private·Collider2D·crank; | 162 | » private·Collider2D·crank; |
| Offset 1, 23 lines modified | Offset 1, 26 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections.Generic; | 2 | using·System.Collections.Generic; |
| 3 | using·System.IO; | 3 | using·System.IO; |
| 4 | using·CsvHelper; | 4 | using·CsvHelper; |
| 5 | using·Rewired; | ||
| 5 | using·TMPro; | 6 | using·TMPro; |
| 6 | using·UnityEngine; | 7 | using·UnityEngine; |
| 7 | using·UnityEngine.UI; | 8 | using·UnityEngine.UI; |
| 8 | 9 | ||
| 9 | public·class·CreditsController·:·MonoBehaviour | 10 | public·class·CreditsController·:·MonoBehaviour |
| 10 | { | 11 | { |
| 11 | » public·event·Action·OnFinish; | 12 | » public·event·Action·OnFinish; |
| 12 | 13 | ||
| 13 | » private·void·Awake() | 14 | » private·void·Awake() |
| 14 | » { | 15 | » { |
| 15 | » » this.creditsRect·=·this.creditMainPanel.GetComponent<RectTransform>(); | 16 | » » this.creditsRect·=·this.creditMainPanel.GetComponent<RectTransform>(); |
| 16 | » » this.LoadCredits(); | 17 | » » this.LoadCredits(); |
| 18 | » » this.defaultCreditsScrollSpeed·=·this.creditScrollSpeed; | ||
| 19 | » » this.player·=·ReInput.players.GetPlayer(0); | ||
| 17 | » } | 20 | » } |
| 18 | 21 | ||
| 19 | » private·void·Start() | 22 | » private·void·Start() |
| 20 | » { | 23 | » { |
| 21 | » » this.remainingDelay·=·this.initialDelay; | 24 | » » this.remainingDelay·=·this.initialDelay; |
| 22 | » » Debug.Log("First·Credit:·"·+·this.credits[0].columns[0]); | 25 | » » Debug.Log("First·Credit:·"·+·this.credits[0].columns[0]); |
| 23 | » » GameObject·gameObject·=·base.gameObject; | 26 | » » GameObject·gameObject·=·base.gameObject; |
| Offset 61, 25 lines modified | Offset 64, 46 lines modified | ||
| 61 | » } | 64 | » } |
| 62 | 65 | ||
| 63 | » private·void·PauseUnpauseCreditsScroll() | 66 | » private·void·PauseUnpauseCreditsScroll() |
| 64 | » { | 67 | » { |
| 65 | » » this.paused·=·!this.paused; | 68 | » » this.paused·=·!this.paused; |
| 66 | » } | 69 | » } |
| 67 | 70 | ||
| 71 | » private·void·Update() | ||
| 72 | » { | ||
| 73 | » » if·(this.player.GetAxis(10)·!=·0f) | ||
| 74 | » » { | ||
| 75 | » » » this.creditScrollSpeed·=·-this.player.GetAxis(10)·*·this.navCreditsScrollSpeed; | ||
| 76 | » » » return; | ||
| 77 | » » } | ||
| 78 | » » if·(this.player.GetButton(44)·||·this.player.GetButton(42)) | ||
| 79 | » » { | ||
| 80 | » » » this.creditScrollSpeed·=·(this.player.GetButton(44)·?·(-this.navCreditsScrollSpeed)·:·this.navCreditsScrollSpeed); | ||
| 81 | » » » return; | ||
| 82 | » » } | ||
| 83 | » » if·(Input.touchCount·>·0·||·Input.GetMouseButton(0)) | ||
| 84 | » » { | ||
| 85 | » » » this.creditScrollSpeed·=·this.navCreditsScrollSpeed; | ||
| 86 | » » » return; | ||
| 87 | » » } | ||
| 88 | » » this.creditScrollSpeed·=·this.defaultCreditsScrollSpeed; | ||
| 89 | » } | ||
| 90 | |||
| 68 | » private·void·FixedUpdate() | 91 | » private·void·FixedUpdate() |
| 69 | » { | 92 | » { |
| 70 | » » if·(!this.paused) | 93 | » » if·(!this.paused) |
| 71 | » » { | 94 | » » { |
| 72 | » » » if·(this.remainingDelay·>·0f) | 95 | » » » if·(this.remainingDelay·>·0f) |
| 73 | » » » { | 96 | » » » { |
| 74 | » » » » this.remainingDelay·-=·Time.unscaledDeltaTime; | 97 | » » » » this.remainingDelay·-=·Time.unscaledDeltaTime; |
| 75 | » » » » return; | 98 | » » » » return; |
| 76 | » » » } | 99 | » » » } |
| 100 | » » » float·num·=·Mathf.Clamp(this.creditMainPanel.transform.localPosition.y·+·this.creditScrollSpeed,·0f,·this.creditsRect.rect.height); | ||
| 77 | » » » this.creditMainPanel.transform.localPosition·=·new·Vector2(this.creditMainPanel.transform.localPosition.x,· | 101 | » » » this.creditMainPanel.transform.localPosition·=·new·Vector2(this.creditMainPanel.transform.localPosition.x,·num); |
| 78 | » » » if·(this.creditsRect. | 102 | » » » if·(this.creditsRect.localPosition.y·>=·this.creditsRect.rect.height·&&·this.OnFinish·!=·null) |
| 79 | » » » { | 103 | » » » { |
| 80 | » » » » this.OnFinish(); | 104 | » » » » this.OnFinish(); |
| 81 | » » » } | 105 | » » » } |
| 82 | » » } | 106 | » » } |
| 83 | » } | 107 | » } |
| 84 | 108 | ||
| 85 | » private·void·GenerateCreditEntry(CreditsController.CreditStruct·credit) | 109 | » private·void·GenerateCreditEntry(CreditsController.CreditStruct·credit) |
| Offset 169, 14 lines modified | Offset 193, 20 lines modified | ||
| 169 | 193 | ||
| 170 | » public·float·startPos·=·230f; | 194 | » public·float·startPos·=·230f; |
| 171 | 195 | ||
| 172 | » private·float·remainingDelay; | 196 | » private·float·remainingDelay; |
| 173 | 197 | ||
| 174 | » private·RectTransform·creditsRect; | 198 | » private·RectTransform·creditsRect; |
| 175 | 199 | ||
| 200 | » private·float·defaultCreditsScrollSpeed; | ||
| 201 | |||
| 202 | » private·float·navCreditsScrollSpeed·=·100f; | ||
| 203 | |||
| 204 | » private·Player·player; | ||
| 205 | |||
| 176 | » private·bool·paused; | 206 | » private·bool·paused; |
| 177 | 207 | ||
| 178 | » public·List<CreditsController.FormatStruct>·formats; | 208 | » public·List<CreditsController.FormatStruct>·formats; |
| 179 | 209 | ||
| 180 | » public·List<CreditsController.CreditStruct>·credits; | 210 | » public·List<CreditsController.CreditStruct>·credits; |
| 181 | 211 | ||
| 182 | » public·enum·CreditType | 212 | » public·enum·CreditType |
| Offset 9, 15 lines modified | Offset 9, 15 lines modified | ||
| 9 | » » { | 9 | » » { |
| 10 | » » » return·false; | 10 | » » » return·false; |
| 11 | » » } | 11 | » » } |
| 12 | » } | 12 | » } |
| 13 | 13 | ||
| 14 | » public·override·bool·CanUse(IUsable·console) | 14 | » public·override·bool·CanUse(IUsable·console) |
| 15 | » { | 15 | » { |
| 16 | » » return·console·is·Console; | 16 | » » return·console·is·ZiplineConsole·||·console·is·Ladder·||·console·is·PlatformConsole·||·console·is·Console·||·console·is·DoorConsole; |
| 17 | » } | 17 | » } |
| 18 | 18 | ||
| 19 | » public·override·bool·DidWin(GameOverReason·gameOverReason) | 19 | » public·override·bool·DidWin(GameOverReason·gameOverReason) |
| 20 | » { | 20 | » { |
| 21 | » » return·GameManager.Instance.DidHumansWin(gameOverReason); | 21 | » » return·GameManager.Instance.DidHumansWin(gameOverReason); |
| 22 | » } | 22 | » } |
| 23 | 23 | ||
| Offset 15, 15 lines modified | Offset 15, 15 lines modified | ||
| 15 | » { | 15 | » { |
| 16 | » » if·(this.crewmateSprites·==·null) | 16 | » » if·(this.crewmateSprites·==·null) |
| 17 | » » { | 17 | » » { |
| 18 | » » » return; | 18 | » » » return; |
| 19 | » » } | 19 | » » } |
| 20 | » » int·num·=·Enumerable.Count<PlayerControl>(PlayerControl.AllPlayerControls,·delegate(PlayerControl·pc) | 20 | » » int·num·=·Enumerable.Count<PlayerControl>(PlayerControl.AllPlayerControls,·delegate(PlayerControl·pc) |
| 21 | » » { | 21 | » » { |
| 22 | » » » | 22 | » » » NetworkedPlayerInfo·data·=·pc.Data; |
| 23 | » » » return·((data·!=·null)·?·data.Role·:·null)·!=·null·&&·!pc.Data.Role.IsImpostor·&&·pc.Data.IsDead; | 23 | » » » return·((data·!=·null)·?·data.Role·:·null)·!=·null·&&·!pc.Data.Role.IsImpostor·&&·pc.Data.IsDead; |
| 24 | » » }); | 24 | » » }); |
| 25 | » » for·(int·i·=·0;·i·<·this.crewmateSprites.Count;·i++) | 25 | » » for·(int·i·=·0;·i·<·this.crewmateSprites.Count;·i++) |
| 26 | » » { | 26 | » » { |
| 27 | » » » if·(i·<·num) | 27 | » » » if·(i·<·num) |
| 28 | » » » { | 28 | » » » { |
| 29 | » » » » if·(!this.crewmateSprites[i].IsKilled) | 29 | » » » » if·(!this.crewmateSprites[i].IsKilled) |
| Offset 38, 15 lines modified | Offset 38, 15 lines modified | ||
| 38 | » » } | 38 | » » } |
| 39 | » } | 39 | » } |
| 40 | 40 | ||
| 41 | » public·void·OnCrewmateDisconnect() | 41 | » public·void·OnCrewmateDisconnect() |
| 42 | » { | 42 | » { |
| 43 | » » int·num·=·Enumerable.Count<PlayerControl>(PlayerControl.AllPlayerControls,·delegate(PlayerControl·pc) | 43 | » » int·num·=·Enumerable.Count<PlayerControl>(PlayerControl.AllPlayerControls,·delegate(PlayerControl·pc) |
| 44 | » » { | 44 | » » { |
| 45 | » » » | 45 | » » » NetworkedPlayerInfo·data·=·pc.Data; |
| 46 | » » » return·((data·!=·null)·?·data.Role·:·null)·!=·null·&&·!pc.Data.Role.IsImpostor; | 46 | » » » return·((data·!=·null)·?·data.Role·:·null)·!=·null·&&·!pc.Data.Role.IsImpostor; |
| 47 | » » }); | 47 | » » }); |
| 48 | » » for·(int·i·=·this.crewmates.Count·-·1;·i·>=·0;·i--) | 48 | » » for·(int·i·=·this.crewmates.Count·-·1;·i·>=·0;·i--) |
| 49 | » » { | 49 | » » { |
| 50 | » » » if·(i·>=·num·-·1) | 50 | » » » if·(i·>=·num·-·1) |
| 51 | » » » { | 51 | » » » { |
| 52 | » » » » this.crewmates.DestroyInstance(this.crewmates.GetInstance(i)); | 52 | » » » » this.crewmates.DestroyInstance(this.crewmates.GetInstance(i)); |
| Offset 70, 15 lines modified | Offset 70, 15 lines modified | ||
| 70 | » private·void·Start() | 70 | » private·void·Start() |
| 71 | » { | 71 | » { |
| 72 | » » this.crewmates.DestroyAll(); | 72 | » » this.crewmates.DestroyAll(); |
| 73 | » » this.crewmateSprites·=·new·List<CrewmateTrackerEntry>(PlayerControl.AllPlayerControls.Count); | 73 | » » this.crewmateSprites·=·new·List<CrewmateTrackerEntry>(PlayerControl.AllPlayerControls.Count); |
| 74 | » » int·num·=·0; | 74 | » » int·num·=·0; |
| 75 | » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) | 75 | » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) |
| 76 | » » { | 76 | » » { |
| 77 | » » » | 77 | » » » NetworkedPlayerInfo·data·=·playerControl.Data; |
| 78 | » » » if·(!(((data·!=·null)·?·data.Role·:·null)·==·null)·&&·!playerControl.Data.Role.IsImpostor) | 78 | » » » if·(!(((data·!=·null)·?·data.Role·:·null)·==·null)·&&·!playerControl.Data.Role.IsImpostor) |
| 79 | » » » { | 79 | » » » { |
| 80 | » » » » CrewmateTrackerEntry·crewmateTrackerEntry·=·this.crewmates.Create<CrewmateTrackerEntry>(); | 80 | » » » » CrewmateTrackerEntry·crewmateTrackerEntry·=·this.crewmates.Create<CrewmateTrackerEntry>(); |
| 81 | » » » » crewmateTrackerEntry.transform.localPosition·=·new·Vector3((float)num·*·this.crewmateSpacing,·0f,·0f); | 81 | » » » » crewmateTrackerEntry.transform.localPosition·=·new·Vector3((float)num·*·this.crewmateSpacing,·0f,·0f); |
| 82 | » » » » crewmateTrackerEntry.transform.localScale·=·this.crewmateScale; | 82 | » » » » crewmateTrackerEntry.transform.localScale·=·this.crewmateScale; |
| 83 | » » » » this.crewmateSprites.Add(crewmateTrackerEntry); | 83 | » » » » this.crewmateSprites.Add(crewmateTrackerEntry); |
| 84 | » » » » num++; | 84 | » » » » num++; |
| Offset 63, 15 lines modified | Offset 63, 15 lines modified | ||
| 63 | » » { | 63 | » » { |
| 64 | » » » this.podIcon.sprite·=·sprite; | 64 | » » » this.podIcon.sprite·=·sprite; |
| 65 | » » })); | 65 | » » })); |
| 66 | » » this.activateButton.SetButtonEnableState(!DestroyableSingleton<CosmicubeManager>.Instance.IsCompleted(cube)·||·flag); | 66 | » » this.activateButton.SetButtonEnableState(!DestroyableSingleton<CosmicubeManager>.Instance.IsCompleted(cube)·||·flag); |
| 67 | » » for·(int·i·=·0;·i·<·this.ColorChips.Count;·i++) | 67 | » » for·(int·i·=·0;·i·<·this.ColorChips.Count;·i++) |
| 68 | » » { | 68 | » » { |
| 69 | » » » ColorChip·colorChip·=·this.ColorChips[i]; | 69 | » » » ColorChip·colorChip·=·this.ColorChips[i]; |
| 70 | » » » colorChip.PlayerEquippedForeground.SetActive(chip·==·colorChip); | 70 | » » » colorChip.PlayerEquippedForeground.SetActive(chip·==·colorChip·&&·flag); |
| 71 | » » } | 71 | » » } |
| 72 | » } | 72 | » } |
| 73 | 73 | ||
| 74 | » public·override·ColorChip·GetDefaultSelectable() | 74 | » public·override·ColorChip·GetDefaultSelectable() |
| 75 | » { | 75 | » { |
| 76 | » » if·(this.ColorChips.Count·>·0) | 76 | » » if·(this.ColorChips.Count·>·0) |
| 77 | » » { | 77 | » » { |
| Offset 177, 26 lines modified | Offset 177, 26 lines modified | ||
| 177 | 177 | ||
| 178 | » [SerializeField] | 178 | » [SerializeField] |
| 179 | » private·Transform·endArea; | 179 | » private·Transform·endArea; |
| 180 | 180 | ||
| 181 | » [SerializeField] | 181 | » [SerializeField] |
| 182 | » private·GameObject·arrow; | 182 | » private·GameObject·arrow; |
| 183 | 183 | ||
| 184 | » [SerializeField] | ||
| 185 | » [Header("Knife")] | 184 | » [Header("Knife")] |
| 185 | » [SerializeField] | ||
| 186 | » private·SpriteRenderer·knife; | 186 | » private·SpriteRenderer·knife; |
| 187 | 187 | ||
| 188 | » [SerializeField] | 188 | » [SerializeField] |
| 189 | » private·Sprite·cuttingKnifeSprite; | 189 | » private·Sprite·cuttingKnifeSprite; |
| 190 | 190 | ||
| 191 | » [SerializeField] | 191 | » [SerializeField] |
| 192 | » private·float·knifeCutYOffset·=·1f; | 192 | » private·float·knifeCutYOffset·=·1f; |
| 193 | 193 | ||
| 194 | » [Header("Audio")] | ||
| 195 | » [SerializeField] | 194 | » [SerializeField] |
| 195 | » [Header("Audio")] | ||
| 196 | » private·AudioClip·getSfx; | 196 | » private·AudioClip·getSfx; |
| 197 | 197 | ||
| 198 | » [SerializeField] | 198 | » [SerializeField] |
| 199 | » private·AudioClip·finishSfx; | 199 | » private·AudioClip·finishSfx; |
| 200 | 200 | ||
| 201 | » [SerializeField] | 201 | » [SerializeField] |
| 202 | » private·AudioClip[]·cutSfx; | 202 | » private·AudioClip[]·cutSfx; |
| Offset 18, 15 lines modified | Offset 18, 15 lines modified | ||
| 18 | » » » return; | 18 | » » » return; |
| 19 | » » } | 19 | » » } |
| 20 | » » Vector2·truePosition·=·PlayerControl.LocalPlayer.GetTruePosition(); | 20 | » » Vector2·truePosition·=·PlayerControl.LocalPlayer.GetTruePosition(); |
| 21 | » » Vector2·truePosition2·=·this.TruePosition; | 21 | » » Vector2·truePosition2·=·this.TruePosition; |
| 22 | » » if·(Vector2.Distance(truePosition2,·truePosition)·<=·PlayerControl.LocalPlayer.MaxReportDistance·&&·PlayerControl.LocalPlayer.CanMove·&&·!PhysicsHelpers.AnythingBetween(truePosition,·truePosition2,·Constants.ShipAndObjectsMask,·false)) | 22 | » » if·(Vector2.Distance(truePosition2,·truePosition)·<=·PlayerControl.LocalPlayer.MaxReportDistance·&&·PlayerControl.LocalPlayer.CanMove·&&·!PhysicsHelpers.AnythingBetween(truePosition,·truePosition2,·Constants.ShipAndObjectsMask,·false)) |
| 23 | » » { | 23 | » » { |
| 24 | » » » this.Reported·=·true; | 24 | » » » this.Reported·=·true; |
| 25 | » » » | 25 | » » » NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(this.ParentId); |
| 26 | » » » PlayerControl.LocalPlayer.CmdReportDeadBody(playerById); | 26 | » » » PlayerControl.LocalPlayer.CmdReportDeadBody(playerById); |
| 27 | » » } | 27 | » » } |
| 28 | » } | 28 | » } |
| 29 | 29 | ||
| 30 | » public·bool·Reported; | 30 | » public·bool·Reported; |
| 31 | 31 | ||
| 32 | » public·byte·ParentId; | 32 | » public·byte·ParentId; |
| Offset 39, 15 lines modified | Offset 39, 15 lines modified | ||
| 39 | » } | 39 | » } |
| 40 | 40 | ||
| 41 | » public·void·Update() | 41 | » public·void·Update() |
| 42 | » { | 42 | » { |
| 43 | » » this.cooldown·=·Mathf.Max(this.cooldown·-·Time.deltaTime,·0f); | 43 | » » this.cooldown·=·Mathf.Max(this.cooldown·-·Time.deltaTime,·0f); |
| 44 | » } | 44 | » } |
| 45 | 45 | ||
| 46 | » public·float·CanUse( | 46 | » public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse) |
| 47 | » { | 47 | » { |
| 48 | » » if·(this.System.CurState·!=·DeconSystem.States.Idle) | 48 | » » if·(this.System.CurState·!=·DeconSystem.States.Idle) |
| 49 | » » { | 49 | » » { |
| 50 | » » » canUse·=·false; | 50 | » » » canUse·=·false; |
| 51 | » » » couldUse·=·false; | 51 | » » » couldUse·=·false; |
| 52 | » » » return·0f; | 52 | » » » return·0f; |
| 53 | » » } | 53 | » » } |
| Offset 29, 18 lines modified | Offset 29, 18 lines modified | ||
| 29 | 29 | ||
| 30 | » public·void·Awake() | 30 | » public·void·Awake() |
| 31 | » { | 31 | » { |
| 32 | » » this.MyDoor·=·base.GetComponent<OpenableDoor>(); | 32 | » » this.MyDoor·=·base.GetComponent<OpenableDoor>(); |
| 33 | » » this.Image·=·base.GetComponent<SpriteRenderer>(); | 33 | » » this.Image·=·base.GetComponent<SpriteRenderer>(); |
| 34 | » } | 34 | » } |
| 35 | 35 | ||
| 36 | » public·float·CanUse( | 36 | » public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse) |
| 37 | » { | 37 | » { |
| 38 | » » float·num·=·Vector2.Distance(pc.Object.GetTruePosition(),·base.transform.position); | 38 | » » float·num·=·Vector2.Distance(pc.Object.GetTruePosition(),·base.transform.position); |
| 39 | » » couldUse·=·!pc.IsDead·&&·!this.MyDoor.IsOpen; | 39 | » » couldUse·=·!pc.IsDead·&&·!this.MyDoor.IsOpen·&&·pc.Role.CanUse(this); |
| 40 | » » canUse·=·couldUse·&&·num·<=·this.UsableDistance; | 40 | » » canUse·=·couldUse·&&·num·<=·this.UsableDistance; |
| 41 | » » return·num; | 41 | » » return·num; |
| 42 | » } | 42 | » } |
| 43 | 43 | ||
| 44 | » public·void·SetOutline(bool·on,·bool·mainTarget) | 44 | » public·void·SetOutline(bool·on,·bool·mainTarget) |
| 45 | » { | 45 | » { |
| 46 | » » if·(this.Image) | 46 | » » if·(this.Image) |
| Offset 1, 50 lines modified | Offset 1, 50 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections.Generic; | 2 | using·System.Collections.Generic; |
| 3 | using·AmongUs.GameOptions; | 3 | using·AmongUs.GameOptions; |
| 4 | 4 | ||
| 5 | public·class·DummyAnalytics·:·IAnalyticsReporter | 5 | public·class·DummyAnalytics·:·IAnalyticsReporter |
| 6 | { | 6 | { |
| 7 | » public·void·StartGame( | 7 | » public·void·StartGame(NetworkedPlayerInfo·localPlayer,·int·playerCount,·int·impostorCount,·NetworkModes·networkMode,·MapNames·map,·GameModes·gameMode,·string·roomCode,·string·serverName,·IGameOptions·options,·List<NetworkedPlayerInfo>·players) |
| 8 | » { | 8 | » { |
| 9 | » } | 9 | » } |
| 10 | 10 | ||
| 11 | » public·void·EndGame(float·durationInSeconds,·GameOverReason·endReason,·List< | 11 | » public·void·EndGame(float·durationInSeconds,·GameOverReason·endReason,·List<NetworkedPlayerInfo>·players) |
| 12 | » { | 12 | » { |
| 13 | » } | 13 | » } |
| 14 | 14 | ||
| 15 | » public·void·VentUsed( | 15 | » public·void·VentUsed(NetworkedPlayerInfo·player) |
| 16 | » { | 16 | » { |
| 17 | » } | 17 | » } |
| 18 | 18 | ||
| 19 | » public·void·Kill( | 19 | » public·void·Kill(NetworkedPlayerInfo·victim,·NetworkedPlayerInfo·killer) |
| 20 | » { | 20 | » { |
| 21 | » } | 21 | » } |
| 22 | 22 | ||
| 23 | » public·void·SabotageStart(SystemTypes·type) | 23 | » public·void·SabotageStart(SystemTypes·type) |
| 24 | » { | 24 | » { |
| 25 | » } | 25 | » } |
| 26 | 26 | ||
| 27 | » public·void·SabotageFixed(SystemTypes·type) | 27 | » public·void·SabotageFixed(SystemTypes·type) |
| 28 | » { | 28 | » { |
| 29 | » } | 29 | » } |
| 30 | 30 | ||
| 31 | » public·void·TaskCompleted( | 31 | » public·void·TaskCompleted(NetworkedPlayerInfo·player,·PlayerTask·task) |
| 32 | » { | 32 | » { |
| 33 | » } | 33 | » } |
| 34 | 34 | ||
| 35 | » public·void·MeetingStarted( | 35 | » public·void·MeetingStarted(NetworkedPlayerInfo·callingPlayer,·bool·bodyReported) |
| 36 | » { | 36 | » { |
| 37 | » } | 37 | » } |
| 38 | 38 | ||
| 39 | » public·void·MeetingEnded(float·durationInSeconds,· | 39 | » public·void·MeetingEnded(float·durationInSeconds,·NetworkedPlayerInfo·playerEjected) |
| 40 | » { | 40 | » { |
| 41 | » } | 41 | » } |
| 42 | 42 | ||
| 43 | » public·void·MinigameOpened( | 43 | » public·void·MinigameOpened(NetworkedPlayerInfo·callingPlayer,·TaskTypes·task) |
| 44 | » { | 44 | » { |
| 45 | » } | 45 | » } |
| 46 | 46 | ||
| 47 | » public·void·MinigameClosed( | 47 | » public·void·MinigameClosed(NetworkedPlayerInfo·callingPlayer,·TaskTypes·task,·float·durationInSeconds,·bool·isCompleted) |
| 48 | » { | 48 | » { |
| 49 | » } | 49 | » } |
| 50 | } | 50 | } |
| Offset 7, 15 lines modified | Offset 7, 15 lines modified | ||
| 7 | » public·void·Start() | 7 | » public·void·Start() |
| 8 | » { | 8 | » { |
| 9 | » » this.myPlayer·=·base.GetComponent<PlayerControl>(); | 9 | » » this.myPlayer·=·base.GetComponent<PlayerControl>(); |
| 10 | » } | 10 | » } |
| 11 | 11 | ||
| 12 | » public·void·Update() | 12 | » public·void·Update() |
| 13 | » { | 13 | » { |
| 14 | » » | 14 | » » NetworkedPlayerInfo·data·=·this.myPlayer.Data; |
| 15 | » » if·(data·==·null·||·data.IsDead) | 15 | » » if·(data·==·null·||·data.IsDead) |
| 16 | » » { | 16 | » » { |
| 17 | » » » return; | 17 | » » » return; |
| 18 | » » } | 18 | » » } |
| 19 | » » if·(MeetingHud.Instance) | 19 | » » if·(MeetingHud.Instance) |
| 20 | » » { | 20 | » » { |
| 21 | » » » if·(!this.voted) | 21 | » » » if·(!this.voted) |
| Offset 48, 18 lines modified | Offset 48, 18 lines modified | ||
| 48 | » » » for·(int·i·=·0;·i·<·100;·i++) | 48 | » » » for·(int·i·=·0;·i·<·100;·i++) |
| 49 | » » » { | 49 | » » » { |
| 50 | » » » » int·num·=·IntRange.Next(-1,·GameData.Instance.PlayerCount); | 50 | » » » » int·num·=·IntRange.Next(-1,·GameData.Instance.PlayerCount); |
| 51 | » » » » if·(num·<·0) | 51 | » » » » if·(num·<·0) |
| 52 | » » » » { | 52 | » » » » { |
| 53 | » » » » » break; | 53 | » » » » » break; |
| 54 | » » » » } | 54 | » » » » } |
| 55 | » » » » | 55 | » » » » NetworkedPlayerInfo·networkedPlayerInfo·=·GameData.Instance.AllPlayers[num]; |
| 56 | » » » » if·(! | 56 | » » » » if·(!networkedPlayerInfo.IsDead) |
| 57 | » » » » { | 57 | » » » » { |
| 58 | » » » » » b·=· | 58 | » » » » » b·=·networkedPlayerInfo.PlayerId; |
| 59 | » » » » » break; | 59 | » » » » » break; |
| 60 | » » » » } | 60 | » » » » } |
| 61 | » » » } | 61 | » » » } |
| 62 | » » } | 62 | » » } |
| 63 | » » this.PlayerIdToVoteFor·=·-1; | 63 | » » this.PlayerIdToVoteFor·=·-1; |
| 64 | » » MeetingHud.Instance.CmdCastVote(this.myPlayer.PlayerId,·b); | 64 | » » MeetingHud.Instance.CmdCastVote(this.myPlayer.PlayerId,·b); |
| 65 | » » yield·break; | 65 | » » yield·break; |
| Offset 11, 108 lines modified | Offset 11, 108 lines modified | ||
| 11 | { | 11 | { |
| 12 | » public·void·Start() | 12 | » public·void·Start() |
| 13 | » { | 13 | » { |
| 14 | » » this.SetEverythingUp(); | 14 | » » this.SetEverythingUp(); |
| 15 | » » base.StartCoroutine(this.CoBegin()); | 15 | » » base.StartCoroutine(this.CoBegin()); |
| 16 | » » base.Invoke("ShowButtons",·1.1f); | 16 | » » base.Invoke("ShowButtons",·1.1f); |
| 17 | » » ConsoleJoystick.SetMode_Menu(); | 17 | » » ConsoleJoystick.SetMode_Menu(); |
| 18 | » » DestroyableSingleton<AchievementManager>.Instance.OnMatchEnd( | 18 | » » DestroyableSingleton<AchievementManager>.Instance.OnMatchEnd(EndGameResult.CachedGameOverReason,·Enumerable.Any<CachedPlayerData>(EndGameResult.CachedWinners,·(CachedPlayerData·h)·=>·h.IsYou)); |
| 19 | » } | 19 | » } |
| 20 | 20 | ||
| 21 | » private·void·ShowButtons() | 21 | » private·void·ShowButtons() |
| 22 | » { | 22 | » { |
| 23 | » » this.FrontMost.gameObject.SetActive(false); | 23 | » » this.FrontMost.gameObject.SetActive(false); |
| 24 | » » if·( | 24 | » » if·(EndGameResult.CachedXpGrantResult.GrantedXp·>·0U·||·EndGameResult.CachedPodsGrantResult.GrantedPodsWithMultiplierApplied·>·0U·||·EndGameResult.CachedBeansGrantResult.GrantedPodsWithMultiplierApplied·>·0U) |
| 25 | » » { | 25 | » » { |
| 26 | » » » this.Navigation.ShowNavigationToProgressionScreen(); | 26 | » » » this.Navigation.ShowNavigationToProgressionScreen(); |
| 27 | » » » return; | 27 | » » » return; |
| 28 | » » } | 28 | » » } |
| 29 | » » this.Navigation.ShowDefaultNavigation(); | 29 | » » this.Navigation.ShowDefaultNavigation(); |
| 30 | » } | 30 | » } |
| 31 | 31 | ||
| 32 | » private·void·SetEverythingUp() | 32 | » private·void·SetEverythingUp() |
| 33 | » { | 33 | » { |
| 34 | » » StatsManager.Instance.IncrementStat(StringNames.StatsGamesFinished); | 34 | » » StatsManager.Instance.IncrementStat(StringNames.StatsGamesFinished); |
| 35 | » » this.Navigation.HideButtons(); | 35 | » » this.Navigation.HideButtons(); |
| 36 | » » bool·flag·=·GameManager.Instance.DidHumansWin( | 36 | » » bool·flag·=·GameManager.Instance.DidHumansWin(EndGameResult.CachedGameOverReason); |
| 37 | » » if·( | 37 | » » if·(EndGameResult.CachedGameOverReason·==·GameOverReason.ImpostorDisconnect) |
| 38 | » » { | 38 | » » { |
| 39 | » » » StatsManager.Instance.AddDrawReason( | 39 | » » » StatsManager.Instance.AddDrawReason(EndGameResult.CachedGameOverReason); |
| 40 | » » » this.WinText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ImpostorDisconnected,·Array.Empty<object>()); | 40 | » » » this.WinText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ImpostorDisconnected,·Array.Empty<object>()); |
| 41 | » » » SoundManager.Instance.PlaySound(this.DisconnectStinger,·false,·1f,·null); | 41 | » » » SoundManager.Instance.PlaySound(this.DisconnectStinger,·false,·1f,·null); |
| 42 | » » } | 42 | » » } |
| 43 | » » else | 43 | » » else |
| 44 | » » { | 44 | » » { |
| 45 | » » » if·(Enumerable.Any< | 45 | » » » if·(Enumerable.Any<CachedPlayerData>(EndGameResult.CachedWinners,·(CachedPlayerData·h)·=>·h.IsYou)) |
| 46 | » » » { | 46 | » » » { |
| 47 | » » » » StatsManager.Instance.AddWinReason( | 47 | » » » » StatsManager.Instance.AddWinReason(EndGameResult.CachedGameOverReason,·(int)GameManager.Instance.LogicOptions.MapId,·EndGameResult.CachedLocalPlayer.RoleWhenAlive); |
| 48 | » » » » DestroyableSingleton<AchievementManager>.Instance.SetWinMap((int)GameManager.Instance.LogicOptions.MapId); | 48 | » » » » DestroyableSingleton<AchievementManager>.Instance.SetWinMap((int)GameManager.Instance.LogicOptions.MapId); |
| 49 | » » » » this.WinText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Victory,·Array.Empty<object>()); | 49 | » » » » this.WinText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Victory,·Array.Empty<object>()); |
| 50 | » » » » this.BackgroundBar.material.SetColor("_Color",·Palette.CrewmateBlue); | 50 | » » » » this.BackgroundBar.material.SetColor("_Color",·Palette.CrewmateBlue); |
| 51 | » » » » | 51 | » » » » CachedPlayerData·cachedPlayerData·=·Enumerable.FirstOrDefault<CachedPlayerData>(EndGameResult.CachedWinners,·(CachedPlayerData·h)·=>·h.IsYou); |
| 52 | » » » » if·( | 52 | » » » » if·(cachedPlayerData·!=·null) |
| 53 | » » » » { | 53 | » » » » { |
| 54 | » » » » » DestroyableSingleton<UnityTelemetry>.Instance.WonGame( | 54 | » » » » » DestroyableSingleton<UnityTelemetry>.Instance.WonGame(cachedPlayerData.ColorId,·cachedPlayerData.HatId,·cachedPlayerData.SkinId,·cachedPlayerData.PetId,·cachedPlayerData.VisorId,·cachedPlayerData.NamePlateId); |
| 55 | » » » » } | 55 | » » » » } |
| 56 | » » » } | 56 | » » » } |
| 57 | » » » else | 57 | » » » else |
| 58 | » » » { | 58 | » » » { |
| 59 | » » » » StatsManager.Instance.AddLoseReason( | 59 | » » » » StatsManager.Instance.AddLoseReason(EndGameResult.CachedGameOverReason); |
| 60 | » » » » this.WinText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Defeat,·Array.Empty<object>()); | 60 | » » » » this.WinText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Defeat,·Array.Empty<object>()); |
| 61 | » » » » this.WinText.color·=·Color.red; | 61 | » » » » this.WinText.color·=·Color.red; |
| 62 | » » » } | 62 | » » » } |
| 63 | » » » if·(flag) | 63 | » » » if·(flag) |
| 64 | » » » { | 64 | » » » { |
| 65 | » » » » SoundManager.Instance.PlayDynamicSound("Stinger",·this.CrewStinger,·false,·new·DynamicSound.GetDynamicsFunction(this.GetStingerVol),·SoundManager.Instance.MusicChannel); | 65 | » » » » SoundManager.Instance.PlayDynamicSound("Stinger",·this.CrewStinger,·false,·new·DynamicSound.GetDynamicsFunction(this.GetStingerVol),·SoundManager.Instance.MusicChannel); |
| 66 | » » » } | 66 | » » » } |
| 67 | » » » else | 67 | » » » else |
| 68 | » » » { | 68 | » » » { |
| 69 | » » » » SoundManager.Instance.PlayDynamicSound("Stinger",·this.ImpostorStinger,·false,·new·DynamicSound.GetDynamicsFunction(this.GetStingerVol),·SoundManager.Instance.MusicChannel); | 69 | » » » » SoundManager.Instance.PlayDynamicSound("Stinger",·this.ImpostorStinger,·false,·new·DynamicSound.GetDynamicsFunction(this.GetStingerVol),·SoundManager.Instance.MusicChannel); |
| 70 | » » » } | 70 | » » » } |
| 71 | » » } | 71 | » » } |
| 72 | » » int·num·=·Mathf.CeilToInt(7.5f); | 72 | » » int·num·=·Mathf.CeilToInt(7.5f); |
| 73 | » » List< | 73 | » » List<CachedPlayerData>·list·=·Enumerable.ToList<CachedPlayerData>(Enumerable.OrderBy<CachedPlayerData,·int>(EndGameResult.CachedWinners,·delegate(CachedPlayerData·b) |
| 74 | » » { | 74 | » » { |
| 75 | » » » if·(!b.IsYou) | 75 | » » » if·(!b.IsYou) |
| 76 | » » » { | 76 | » » » { |
| 77 | » » » » return·0; | 77 | » » » » return·0; |
| 78 | » » » } | 78 | » » » } |
| 79 | » » » return·-1; | 79 | » » » return·-1; |
| 80 | » » })); | 80 | » » })); |
| 81 | » » for·(int·i·=·0;·i·<·list.Count;·i++) | 81 | » » for·(int·i·=·0;·i·<·list.Count;·i++) |
| 82 | » » { | 82 | » » { |
| 83 | » » » | 83 | » » » CachedPlayerData·cachedPlayerData2·=·list[i]; |
| 84 | » » » int·num2·=·((i·%·2·==·0)·?·(-1)·:·1); | 84 | » » » int·num2·=·((i·%·2·==·0)·?·(-1)·:·1); |
| 85 | » » » int·num3·=·(i·+·1)·/·2; | 85 | » » » int·num3·=·(i·+·1)·/·2; |
| 86 | » » » float·num4·=·(float)num3·/·(float)num; | 86 | » » » float·num4·=·(float)num3·/·(float)num; |
| 87 | » » » float·num5·=·Mathf.Lerp(1f,·0.75f,·num4); | 87 | » » » float·num5·=·Mathf.Lerp(1f,·0.75f,·num4); |
| 88 | » » » float·num6·=·(float)((i·==·0)·?·(-8)·:·(-1)); | 88 | » » » float·num6·=·(float)((i·==·0)·?·(-8)·:·(-1)); |
| 89 | » » » PoolablePlayer·poolablePlayer·=·Object.Instantiate<PoolablePlayer>(this.PlayerPrefab,·base.transform); | 89 | » » » PoolablePlayer·poolablePlayer·=·Object.Instantiate<PoolablePlayer>(this.PlayerPrefab,·base.transform); |
| 90 | » » » poolablePlayer.transform.localPosition·=·new·Vector3(1f·*·(float)num2·*·(float)num3·*·num5,·FloatRange.SpreadToEdges(-1.125f,·0f,·num3,·num),·num6·+·(float)num3·*·0.01f)·*·0.9f; | 90 | » » » poolablePlayer.transform.localPosition·=·new·Vector3(1f·*·(float)num2·*·(float)num3·*·num5,·FloatRange.SpreadToEdges(-1.125f,·0f,·num3,·num),·num6·+·(float)num3·*·0.01f)·*·0.9f; |
| 91 | » » » float·num7·=·Mathf.Lerp(1f,·0.65f,·num4)·*·0.9f; | 91 | » » » float·num7·=·Mathf.Lerp(1f,·0.65f,·num4)·*·0.9f; |
| 92 | » » » Vector3·vector·=·new·Vector3(num7,·num7,·1f); | 92 | » » » Vector3·vector·=·new·Vector3(num7,·num7,·1f); |
| 93 | » » » poolablePlayer.transform.localScale·=·vector; | 93 | » » » poolablePlayer.transform.localScale·=·vector; |
| 94 | » » » if·( | 94 | » » » if·(cachedPlayerData2.IsDead) |
| 95 | » » » { | 95 | » » » { |
| 96 | » » » » poolablePlayer.SetBodyAsGhost(); | 96 | » » » » poolablePlayer.SetBodyAsGhost(); |
| 97 | » » » » poolablePlayer.SetDeadFlipX(i·%·2·==·0); | 97 | » » » » poolablePlayer.SetDeadFlipX(i·%·2·==·0); |
| 98 | » » » } | 98 | » » » } |
| 99 | » » » else | 99 | » » » else |
| 100 | » » » { | 100 | » » » { |
| 101 | » » » » poolablePlayer.SetFlipX(i·%·2·==·0); | 101 | » » » » poolablePlayer.SetFlipX(i·%·2·==·0); |
| 102 | » » » } | 102 | » » » } |
| 103 | » » » poolablePlayer.UpdateFromPlayerOutfit( | 103 | » » » poolablePlayer.UpdateFromPlayerOutfit(cachedPlayerData2.Outfit,·PlayerMaterial.MaskType.None,·cachedPlayerData2.IsDead,·true,·null,·false); |
| 104 | » » » if·(flag) | 104 | » » » if·(flag) |
| 105 | » » » { | 105 | » » » { |
| 106 | » » » » poolablePlayer.ToggleName(false); | 106 | » » » » poolablePlayer.ToggleName(false); |
| 107 | » » » } | 107 | » » » } |
| 108 | » » » else | 108 | » » » else |
| 109 | » » » { | 109 | » » » { |
| 110 | » » » » Color·color·=·( | 110 | » » » » Color·color·=·(cachedPlayerData2.IsImpostor·?·Palette.ImpostorRed·:·Palette.White); |
| 111 | » » » » poolablePlayer.SetName( | 111 | » » » » poolablePlayer.SetName(cachedPlayerData2.PlayerName,·vector.Inv(),·color,·-15f); |
| 112 | » » » » Vector3·vector2·=·new·Vector3(0f,·-1.31f,·-0.5f); | 112 | » » » » Vector3·vector2·=·new·Vector3(0f,·-1.31f,·-0.5f); |
| 113 | » » » » poolablePlayer.SetNamePosition(vector2); | 113 | » » » » poolablePlayer.SetNamePosition(vector2); |
| 114 | » » » » if·(AprilFoolsMode.ShouldHorseAround()·&&·GameOptionsManager.Instance.CurrentGameOptions.GameMode·==·GameModes.HideNSeek) | 114 | » » » » if·(AprilFoolsMode.ShouldHorseAround()·&&·GameOptionsManager.Instance.CurrentGameOptions.GameMode·==·GameModes.HideNSeek) |
| 115 | » » » » { | 115 | » » » » { |
| 116 | » » » » » poolablePlayer.SetBodyType(PlayerBodyTypes.Normal); | 116 | » » » » » poolablePlayer.SetBodyType(PlayerBodyTypes.Normal); |
| 117 | » » » » » poolablePlayer.SetFlipX(false); | 117 | » » » » » poolablePlayer.SetFlipX(false); |
| 118 | » » » » } | 118 | » » » » } |
| Offset 29, 17 lines modified | Offset 29, 17 lines modified | ||
| 29 | » » this.ContinueButton.SetActive(false); | 29 | » » this.ContinueButton.SetActive(false); |
| 30 | » } | 30 | » } |
| 31 | 31 | ||
| 32 | » public·void·NextGame() | 32 | » public·void·NextGame() |
| 33 | » { | 33 | » { |
| 34 | » » this.PlayAgainButton.gameObject.SetActive(false); | 34 | » » this.PlayAgainButton.gameObject.SetActive(false); |
| 35 | » » this.ExitButton.gameObject.SetActive(false); | 35 | » » this.ExitButton.gameObject.SetActive(false); |
| 36 | » » if·( | 36 | » » if·(EndGameResult.CachedShowAd·&&·!DataManager.Player.Ads.HasPurchasedAdRemoval) |
| 37 | » » { | 37 | » » { |
| 38 | » » » | 38 | » » » EndGameResult.CachedShowAd·=·false; |
| 39 | » » } | 39 | » » } |
| 40 | » » GameManager.DestroyInstance(); | 40 | » » GameManager.DestroyInstance(); |
| 41 | » » base.StartCoroutine(this.CoJoinGame()); | 41 | » » base.StartCoroutine(this.CoJoinGame()); |
| 42 | » } | 42 | » } |
| 43 | 43 | ||
| 44 | » public·void·Exit() | 44 | » public·void·Exit() |
| 45 | » { | 45 | » { |
| Offset 1, 28 lines modified | Offset 1, 37 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections.Generic; | ||
| 2 | using·Hazel; | 3 | using·Hazel; |
| 3 | 4 | ||
| 4 | public·class·EndGameResult | 5 | public·class·EndGameResult |
| 5 | { | 6 | { |
| 6 | » p | 7 | » private·EndGameResult(GameOverReason·gameOverReason,·bool·showAd,·ProgressionManager.XpGrantResult·xpGrantResult·=·null,·ProgressionManager.CurrencyGrantResult·podsGrantResult·=·null,·ProgressionManager.CurrencyGrantResult·beansGrantResult·=·null) |
| 7 | » { | 8 | » { |
| 8 | » » this.GameOverReason·=·gameOverReason; | 9 | » » this.GameOverReason·=·gameOverReason; |
| 9 | » » this.ShowAd·=·showAd; | 10 | » » this.ShowAd·=·showAd; |
| 10 | » » this.XpGrantResult·=·xpGrantResult; | 11 | » » this.XpGrantResult·=·xpGrantResult; |
| 11 | » » this.BeansGrantResult·=·beansGrantResult; | ||
| 12 | » » this.PodsGrantResult·=·podsGrantResult; | 12 | » » this.PodsGrantResult·=·podsGrantResult; |
| 13 | » » this.BeansGrantResult·=·beansGrantResult; | ||
| 14 | » » EndGameResult.ResetCachedValues(); | ||
| 15 | » » EndGameResult.CachedGameOverReason·=·this.GameOverReason; | ||
| 16 | » » EndGameResult.CachedShowAd·=·this.ShowAd; | ||
| 17 | » » EndGameResult.CachedXpGrantResult·=·this.XpGrantResult; | ||
| 18 | » » EndGameResult.CachedPodsGrantResult·=·this.PodsGrantResult; | ||
| 19 | » » EndGameResult.CachedBeansGrantResult·=·this.BeansGrantResult; | ||
| 13 | » } | 20 | » } |
| 14 | 21 | ||
| 15 | » public· | 22 | » public·static·void·ResetCachedValues() |
| 16 | » { | 23 | » { |
| 17 | » » this.GameOverReason·=·gameOverReason; | ||
| 18 | » » this.ShowAd·=·showAd; | ||
| 19 | » » this.XpGrantResult·=·null; | ||
| 20 | » » this.BeansGrantResult·=·null; | ||
| 21 | » » | 24 | » » EndGameResult.CachedWinners.Clear(); |
| 25 | » » EndGameResult.CachedLocalPlayer·=·null; | ||
| 26 | » » EndGameResult.CachedGameOverReason·=·GameOverReason.HumansByTask; | ||
| 27 | » » EndGameResult.CachedShowAd·=·false; | ||
| 28 | » » EndGameResult.CachedXpGrantResult·=·null; | ||
| 29 | » » EndGameResult.CachedPodsGrantResult·=·null; | ||
| 30 | » » EndGameResult.CachedBeansGrantResult·=·null; | ||
| 22 | » } | 31 | » } |
| 23 | 32 | ||
| 24 | » public·static·EndGameResult·Create(MessageReader·reader) | 33 | » public·static·EndGameResult·Create(MessageReader·reader) |
| 25 | » { | 34 | » { |
| 26 | » » GameOverReason·gameOverReason·=·(GameOverReason)reader.ReadByte(); | 35 | » » GameOverReason·gameOverReason·=·(GameOverReason)reader.ReadByte(); |
| 27 | » » bool·flag·=·reader.ReadBoolean(); | 36 | » » bool·flag·=·reader.ReadBoolean(); |
| 28 | » » if·(reader.Position·<·reader.Length) | 37 | » » if·(reader.Position·<·reader.Length) |
| Offset 54, 20 lines modified | Offset 63, 34 lines modified | ||
| 54 | » » » » } | 63 | » » » » } |
| 55 | » » » » ProgressionManager.XpGrantResult·xpGrantResult·=·new·ProgressionManager.XpGrantResult(num2,·num,·num3,·num11,·flag2,·num4,·num5,·num6); | 64 | » » » » ProgressionManager.XpGrantResult·xpGrantResult·=·new·ProgressionManager.XpGrantResult(num2,·num,·num3,·num11,·flag2,·num4,·num5,·num6); |
| 56 | » » » » ProgressionManager.CurrencyGrantResult·currencyGrantResult·=·new·ProgressionManager.CurrencyGrantResult(text,·(uint)DestroyableSingleton<InventoryManager>.Instance.GetPodCount(text),·num7,·num9); | 65 | » » » » ProgressionManager.CurrencyGrantResult·currencyGrantResult·=·new·ProgressionManager.CurrencyGrantResult(text,·(uint)DestroyableSingleton<InventoryManager>.Instance.GetPodCount(text),·num7,·num9); |
| 57 | » » » » ProgressionManager.CurrencyGrantResult·currencyGrantResult2·=·new·ProgressionManager.CurrencyGrantResult(Constants.Beans,·(uint)DestroyableSingleton<InventoryManager>.Instance.UnusedBeans,·num8,·num10); | 66 | » » » » ProgressionManager.CurrencyGrantResult·currencyGrantResult2·=·new·ProgressionManager.CurrencyGrantResult(Constants.Beans,·(uint)DestroyableSingleton<InventoryManager>.Instance.UnusedBeans,·num8,·num10); |
| 58 | » » » » return·new·EndGameResult(gameOverReason,·flag,·xpGrantResult,·currencyGrantResult,·currencyGrantResult2); | 67 | » » » » return·new·EndGameResult(gameOverReason,·flag,·xpGrantResult,·currencyGrantResult,·currencyGrantResult2); |
| 59 | » » » } | 68 | » » » } |
| 60 | » » } | 69 | » » } |
| 61 | » » return·new·EndGameResult(gameOverReason,·flag); | 70 | » » return·new·EndGameResult(gameOverReason,·flag,·null,·null,·null); |
| 62 | » } | 71 | » } |
| 63 | 72 | ||
| 73 | » public·static·List<CachedPlayerData>·CachedWinners·=·new·List<CachedPlayerData>(); | ||
| 74 | |||
| 75 | » public·static·CachedPlayerData·CachedLocalPlayer; | ||
| 76 | |||
| 77 | » public·static·GameOverReason·CachedGameOverReason·=·GameOverReason.HumansByTask; | ||
| 78 | |||
| 79 | » public·static·bool·CachedShowAd; | ||
| 80 | |||
| 81 | » public·static·ProgressionManager.XpGrantResult·CachedXpGrantResult; | ||
| 82 | |||
| 83 | » public·static·ProgressionManager.CurrencyGrantResult·CachedBeansGrantResult; | ||
| 84 | |||
| 85 | » public·static·ProgressionManager.CurrencyGrantResult·CachedPodsGrantResult; | ||
| 86 | |||
| 64 | » public·readonly·GameOverReason·GameOverReason; | 87 | » public·readonly·GameOverReason·GameOverReason; |
| 65 | 88 | ||
| 66 | » public·readonly·bool·ShowAd; | 89 | » public·readonly·bool·ShowAd; |
| 67 | 90 | ||
| 68 | » public·readonly·ProgressionManager.XpGrantResult·XpGrantResult; | 91 | » public·readonly·ProgressionManager.XpGrantResult·XpGrantResult; |
| 69 | 92 | ||
| 70 | » public·readonly·ProgressionManager.CurrencyGrantResult·BeansGrantResult; | ||
| 71 | |||
| 72 | » public·readonly·ProgressionManager.CurrencyGrantResult·PodsGrantResult; | 93 | » public·readonly·ProgressionManager.CurrencyGrantResult·PodsGrantResult; |
| 94 | |||
| 95 | » public·readonly·ProgressionManager.CurrencyGrantResult·BeansGrantResult; | ||
| 73 | } | 96 | } |
| Offset 43, 15 lines modified | Offset 43, 15 lines modified | ||
| 43 | 43 | ||
| 44 | » public·override·bool·CanUse(IUsable·console) | 44 | » public·override·bool·CanUse(IUsable·console) |
| 45 | » { | 45 | » { |
| 46 | » » if·(console·is·Vent) | 46 | » » if·(console·is·Vent) |
| 47 | » » { | 47 | » » { |
| 48 | » » » return·(!this.IsAffectedByComms·||·this.Player.inVent)·&&·this.usesRemaining·>·0; | 48 | » » » return·(!this.IsAffectedByComms·||·this.Player.inVent)·&&·this.usesRemaining·>·0; |
| 49 | » » } | 49 | » » } |
| 50 | » » return·console·is·Console; | 50 | » » return·console·is·ZiplineConsole·||·console·is·Ladder·||·console·is·PlatformConsole·||·console·is·Console·||·console·is·DoorConsole; |
| 51 | » } | 51 | » } |
| 52 | 52 | ||
| 53 | » public·override·bool·DidWin(GameOverReason·gameOverReason) | 53 | » public·override·bool·DidWin(GameOverReason·gameOverReason) |
| 54 | » { | 54 | » { |
| 55 | » » return·GameManager.Instance.DidHumansWin(gameOverReason); | 55 | » » return·GameManager.Instance.DidHumansWin(gameOverReason); |
| 56 | » } | 56 | » } |
| 57 | 57 | ||
| Offset 2, 14 lines modified | Offset 2, 16 lines modified | ||
| 2 | using·System.Collections; | 2 | using·System.Collections; |
| 3 | using·System.Linq; | 3 | using·System.Linq; |
| 4 | using·TMPro; | 4 | using·TMPro; |
| 5 | using·UnityEngine; | 5 | using·UnityEngine; |
| 6 | 6 | ||
| 7 | public·abstract·class·ExileController·:·MonoBehaviour | 7 | public·abstract·class·ExileController·:·MonoBehaviour |
| 8 | { | 8 | { |
| 9 | » public·event·Action·OnCompleteEvent; | ||
| 10 | |||
| 9 | » private·void·Awake() | 11 | » private·void·Awake() |
| 10 | » { | 12 | » { |
| 11 | » » this.specialInputHandler·=·base.GetComponent<SpecialInputHandler>(); | 13 | » » this.specialInputHandler·=·base.GetComponent<SpecialInputHandler>(); |
| 12 | » } | 14 | » } |
| 13 | 15 | ||
| 14 | » protected·abstract·IEnumerator·Animate(); | 16 | » protected·abstract·IEnumerator·Animate(); |
| 15 | 17 | ||
| Offset 30, 112 lines modified | Offset 32, 147 lines modified | ||
| 30 | » » » } | 32 | » » » } |
| 31 | » » » yield·return·null; | 33 | » » » yield·return·null; |
| 32 | » » } | 34 | » » } |
| 33 | » » this.Text.text·=·this.completeString; | 35 | » » this.Text.text·=·this.completeString; |
| 34 | » » yield·break; | 36 | » » yield·break; |
| 35 | » } | 37 | » } |
| 36 | 38 | ||
| 37 | » public·void·Begin( | 39 | » public·void·BeginForTesting(NetworkedPlayerInfo.PlayerOutfit·outfit,·bool·voteTie·=·false,·bool·isImpostor·=·true,·bool·confirmImpostor·=·true,·int·totalImpostorCount·=·1,·int·remainingImpostorCount·=·0) |
| 40 | » { | ||
| 41 | » » this.Begin(new·ExileController.InitProperties | ||
| 42 | » » { | ||
| 43 | » » » outfit·=·outfit, | ||
| 44 | » » » isImpostor·=·isImpostor, | ||
| 45 | » » » confirmImpostor·=·confirmImpostor, | ||
| 46 | » » » voteTie·=·voteTie, | ||
| 47 | » » » totalImpostorCount·=·totalImpostorCount, | ||
| 48 | » » » remainingImpostorCount·=·remainingImpostorCount | ||
| 49 | » » }); | ||
| 50 | » } | ||
| 51 | |||
| 52 | » public·void·BeginForGameplay(NetworkedPlayerInfo·player,·bool·voteTie) | ||
| 53 | » { | ||
| 54 | » » ExileController.InitProperties·initProperties·=·new·ExileController.InitProperties(); | ||
| 55 | » » if·(player·!=·null) | ||
| 56 | » » { | ||
| 57 | » » » initProperties.outfit·=·player.Outfits[PlayerOutfitType.Default]; | ||
| 58 | » » » initProperties.networkedPlayer·=·player; | ||
| 59 | » » » initProperties.isImpostor·=·player.Role.IsImpostor; | ||
| 60 | » » } | ||
| 61 | » » initProperties.voteTie·=·voteTie; | ||
| 62 | » » initProperties.confirmImpostor·=·GameManager.Instance.LogicOptions.GetConfirmImpostor(); | ||
| 63 | » » initProperties.totalImpostorCount·=·Enumerable.Count<NetworkedPlayerInfo>(GameData.Instance.AllPlayers,·(NetworkedPlayerInfo·p)·=>·p.Role.IsImpostor); | ||
| 64 | » » initProperties.remainingImpostorCount·=·Enumerable.Count<NetworkedPlayerInfo>(GameData.Instance.AllPlayers,·(NetworkedPlayerInfo·p)·=>·p.Role.IsImpostor·&&·!p.IsDead·&&·!p.Disconnected); | ||
| 65 | » » if·(player·!=·null·&&·player.Role.IsImpostor·&&·!player.Disconnected) | ||
| 66 | » » { | ||
| 67 | » » » initProperties.remainingImpostorCount--; | ||
| 68 | » » } | ||
| 69 | » » this.Begin(initProperties); | ||
| 70 | » } | ||
| 71 | |||
| 72 | » private·void·Begin(ExileController.InitProperties·init) | ||
| 38 | » { | 73 | » { |
| 39 | » » if·(this.specialInputHandler·!=·null) | 74 | » » if·(this.specialInputHandler·!=·null) |
| 40 | » » { | 75 | » » { |
| 41 | » » » this.specialInputHandler.disableVirtualCursor·=·true; | 76 | » » » this.specialInputHandler.disableVirtualCursor·=·true; |
| 42 | » » } | 77 | » » } |
| 43 | » » ExileController.Instance·=·this; | 78 | » » ExileController.Instance·=·this; |
| 44 | » » ControllerManager.Instance.CloseAndResetAll(); | 79 | » » ControllerManager.Instance.CloseAndResetAll(); |
| 45 | » » this. | 80 | » » this.initData·=·init; |
| 46 | » » this.Text.gameObject.SetActive(false); | 81 | » » this.Text.gameObject.SetActive(false); |
| 47 | » » this.Text.text·=·string.Empty; | 82 | » » this.Text.text·=·string.Empty; |
| 83 | » » if·(init·!=·null·&&·init.outfit·!=·null) | ||
| 48 | » » int·num·=·Enumerable.Count<GameData.PlayerInfo>(GameData.Instance.AllPlayers,·(GameData.PlayerInfo·p)·=>·p.Role.IsImpostor·&&·!p.IsDead·&&·!p.Disconnected); | ||
| 49 | » » if·(exiled·!=·null) | ||
| 50 | » » { | 84 | » » { |
| 85 | » » » if·(!init.confirmImpostor) | ||
| 51 | » » » int·num2·=·Enumerable.Count<GameData.PlayerInfo>(GameData.Instance.AllPlayers,·(GameData.PlayerInfo·p)·=>·p.Role.IsImpostor); | ||
| 52 | » » » if·(!GameManager.Instance.LogicOptions.GetConfirmImpostor()) | ||
| 53 | » » » { | 86 | » » » { |
| 54 | » » » » this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextNonConfirm,·new·object[]·{· | 87 | » » » » this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextNonConfirm,·new·object[]·{·init.outfit.PlayerName·}); |
| 55 | » » » } | 88 | » » » } |
| 56 | » » » else·if·( | 89 | » » » else·if·(init.isImpostor) |
| 57 | » » » { | 90 | » » » { |
| 58 | » » » » if·(nu | 91 | » » » » if·(init.totalImpostorCount·>·1) |
| 59 | » » » » { | 92 | » » » » { |
| 60 | » » » » » this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextPP,·new·object[]·{· | 93 | » » » » » this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextPP,·new·object[]·{·init.outfit.PlayerName·}); |
| 61 | » » » » } | 94 | » » » » } |
| 62 | » » » » else | 95 | » » » » else |
| 63 | » » » » { | 96 | » » » » { |
| 64 | » » » » » this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextSP,·new·object[]·{· | 97 | » » » » » this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextSP,·new·object[]·{·init.outfit.PlayerName·}); |
| 65 | » » » » } | 98 | » » » » } |
| 66 | » » » } | 99 | » » » } |
| 67 | » » » else·if·(nu | 100 | » » » else·if·(init.totalImpostorCount·>·1) |
| 68 | » » » { | 101 | » » » { |
| 69 | » » » » this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextPN,·new·object[]·{· | 102 | » » » » this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextPN,·new·object[]·{·init.outfit.PlayerName·}); |
| 70 | » » » } | 103 | » » » } |
| 71 | » » » else | 104 | » » » else |
| 72 | » » » { | 105 | » » » { |
| 73 | » » » » this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextSN,·new·object[]·{· | 106 | » » » » this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextSN,·new·object[]·{·init.outfit.PlayerName·}); |
| 74 | » » » } | 107 | » » » } |
| 75 | » » » this.Player.UpdateFrom | 108 | » » » this.Player.UpdateFromPlayerOutfit(init.outfit,·PlayerMaterial.MaskType.Exile,·false,·false,·delegate |
| 76 | » » » { | 109 | » » » { |
| 77 | » » » » SkinViewData·skinViewData | 110 | » » » » SkinViewData·skinViewData; |
| 111 | » » » » if·(GameManager.Instance·!=·null) | ||
| 112 | » » » » { | ||
| 113 | » » » » » skinViewData·=·ShipStatus.Instance.CosmeticsCache.GetSkin(this.initData.outfit.SkinId); | ||
| 114 | » » » » } | ||
| 115 | » » » » else | ||
| 116 | » » » » { | ||
| 117 | » » » » » skinViewData·=·this.Player.GetSkinView(); | ||
| 118 | » » » » } | ||
| 78 | » » » » if·(!DestroyableSingleton<HatManager>.Instance.CheckLongModeValidCosmetic( | 119 | » » » » if·(GameManager.Instance·!=·null·&&·!DestroyableSingleton<HatManager>.Instance.CheckLongModeValidCosmetic(init.outfit.SkinId,·this.Player.GetIgnoreLongMode())) |
| 79 | » » » » { | 120 | » » » » { |
| 80 | » » » » » skinViewData·=·ShipStatus.Instance.CosmeticsCache.GetSkin("skin_None"); | 121 | » » » » » skinViewData·=·ShipStatus.Instance.CosmeticsCache.GetSkin("skin_None"); |
| 81 | » » » » } | 122 | » » » » } |
| 82 | » » » » if·(this.useIdleAnim) | 123 | » » » » if·(this.useIdleAnim) |
| 83 | » » » » { | 124 | » » » » { |
| 84 | » » » » » this.Player.FixSkinSprite(skinViewData.IdleFrame); | 125 | » » » » » this.Player.FixSkinSprite(skinViewData.IdleFrame); |
| 85 | » » » » » return; | 126 | » » » » » return; |
| 86 | » » » » } | 127 | » » » » } |
| 87 | » » » » this.Player.FixSkinSprite(skinViewData.EjectFrame); | 128 | » » » » this.Player.FixSkinSprite(skinViewData.EjectFrame); |
| 88 | » » » }); | 129 | » » » },·false); |
| 89 | » » » this.Player.ToggleName(false); | 130 | » » » this.Player.ToggleName(false); |
| 90 | » » » if·(!this.useIdleAnim) | 131 | » » » if·(!this.useIdleAnim) |
| 91 | » » » { | 132 | » » » { |
| 92 | » » » » this.Player.SetCustomHatPosition(this.exileHatPosition); | 133 | » » » » this.Player.SetCustomHatPosition(this.exileHatPosition); |
| 93 | » » » » this.Player.SetCustomVisorPosition(this.exileVisorPosition); | 134 | » » » » this.Player.SetCustomVisorPosition(this.exileVisorPosition); |
| 94 | » » » } | 135 | » » » } |
| 95 | » » » if·(exiled.Role.IsImpostor·&&·!exiled.Disconnected) | ||
| 96 | » » » { | ||
| Max diff block lines reached; 2713/9086 bytes (29.86%) of diff not shown. | |||
| Offset 86, 39 lines modified | Offset 86, 39 lines modified | ||
| 86 | » » VibrationManager.Vibrate(0.3f,·0.3f,·0.1f,·VibrationManager.VibrationFalloff.None,·null,·false,·""); | 86 | » » VibrationManager.Vibrate(0.3f,·0.3f,·0.1f,·VibrationManager.VibrationFalloff.None,·null,·false,·""); |
| 87 | » » if·(Constants.ShouldPlaySfx()) | 87 | » » if·(Constants.ShouldPlaySfx()) |
| 88 | » » { | 88 | » » { |
| 89 | » » » SoundManager.Instance.PlaySoundImmediate(this.leafSfx.Random<AudioClip>(),·false,·1f,·Random.Range(1f·-·this.leafSfxPitchRange,·1f·+·this.leafSfxPitchRange),·null); | 89 | » » » SoundManager.Instance.PlaySoundImmediate(this.leafSfx.Random<AudioClip>(),·false,·1f,·Random.Range(1f·-·this.leafSfxPitchRange,·1f·+·this.leafSfxPitchRange),·null); |
| 90 | » » } | 90 | » » } |
| 91 | » } | 91 | » } |
| 92 | 92 | ||
| 93 | » [Header("Egg")] | ||
| 94 | » [SerializeField] | 93 | » [SerializeField] |
| 94 | » [Header("Egg")] | ||
| 95 | » private·Transform[]·spawnPoints; | 95 | » private·Transform[]·spawnPoints; |
| 96 | 96 | ||
| 97 | » [SerializeField] | 97 | » [SerializeField] |
| 98 | » private·Transform·egg; | 98 | » private·Transform·egg; |
| 99 | 99 | ||
| 100 | » [SerializeField] | 100 | » [SerializeField] |
| 101 | » private·PassiveButton·eggButton; | 101 | » private·PassiveButton·eggButton; |
| 102 | 102 | ||
| 103 | » [Header("Leaves")] | ||
| 104 | » [SerializeField] | 103 | » [SerializeField] |
| 104 | » [Header("Leaves")] | ||
| 105 | » private·EggCoveringLeaf[]·leaves; | 105 | » private·EggCoveringLeaf[]·leaves; |
| 106 | 106 | ||
| 107 | » [SerializeField] | ||
| 108 | » [Header("Cursor")] | 107 | » [Header("Cursor")] |
| 108 | » [SerializeField] | ||
| 109 | » private·Transform·hand; | 109 | » private·Transform·hand; |
| 110 | 110 | ||
| 111 | » [Header("Audio")] | 111 | » [Header("Audio")] |
| 112 | » [SerializeField] | 112 | » [SerializeField] |
| 113 | » private·AudioClip·eggGetSfx; | 113 | » private·AudioClip·eggGetSfx; |
| 114 | 114 | ||
| 115 | » [Space(10f)] | ||
| 115 | » [SerializeField] | 116 | » [SerializeField] |
| 116 | » [Range(0f,·1f)] | 117 | » [Range(0f,·1f)] |
| 117 | » [Space(10f)] | ||
| 118 | » private·float·leafSfxPitchRange·=·0.2f; | 118 | » private·float·leafSfxPitchRange·=·0.2f; |
| 119 | 119 | ||
| 120 | » [SerializeField] | 120 | » [SerializeField] |
| 121 | » private·AudioClip[]·leafSfx; | 121 | » private·AudioClip[]·leafSfx; |
| 122 | 122 | ||
| 123 | » private·Controller·controller·=·new·Controller(); | 123 | » private·Controller·controller·=·new·Controller(); |
| 124 | 124 | ||
| Offset 1, 12 lines modified | Offset 1, 12 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·UnityEngine; | 2 | using·UnityEngine; |
| 3 | 3 | ||
| 4 | [RequireComponent(typeof(MeshRenderer))] | ||
| 5 | [RequireComponent(typeof(MeshFilter))] | 4 | [RequireComponent(typeof(MeshFilter))] |
| 5 | [RequireComponent(typeof(MeshRenderer))] | ||
| 6 | public·class·FlatWaveBehaviour·:·MonoBehaviour | 6 | public·class·FlatWaveBehaviour·:·MonoBehaviour |
| 7 | { | 7 | { |
| 8 | » public·void·Start() | 8 | » public·void·Start() |
| 9 | » { | 9 | » { |
| 10 | » » this.mesh·=·new·Mesh(); | 10 | » » this.mesh·=·new·Mesh(); |
| 11 | » » base.GetComponent<MeshFilter>().mesh·=·this.mesh; | 11 | » » base.GetComponent<MeshFilter>().mesh·=·this.mesh; |
| 12 | » » this.mesh.MarkDynamic(); | 12 | » » this.mesh.MarkDynamic(); |
| Offset 56, 11 lines modified | Offset 56, 11 lines modified | ||
| 56 | » [SerializeField] | 56 | » [SerializeField] |
| 57 | » private·FreeplayPopoverButton[]·buttons; | 57 | » private·FreeplayPopoverButton[]·buttons; |
| 58 | 58 | ||
| 59 | » [Space(10f)] | 59 | » [Space(10f)] |
| 60 | » [SerializeField] | 60 | » [SerializeField] |
| 61 | » private·HostLocalGameButton·hostGameButton; | 61 | » private·HostLocalGameButton·hostGameButton; |
| 62 | 62 | ||
| 63 | » [SerializeField] | ||
| 64 | » [Header("Console·Controller·Navigation")] | 63 | » [Header("Console·Controller·Navigation")] |
| 64 | » [SerializeField] | ||
| 65 | » private·UiElement·backButton; | 65 | » private·UiElement·backButton; |
| 66 | } | 66 | } |
| Offset 14, 33 lines modified | Offset 14, 20 lines modified | ||
| 14 | » private·void·OnDestroy() | 14 | » private·void·OnDestroy() |
| 15 | » { | 15 | » { |
| 16 | » » SceneManager.sceneLoaded·-=·this.OnSceneLoaded; | 16 | » » SceneManager.sceneLoaded·-=·this.OnSceneLoaded; |
| 17 | » } | 17 | » } |
| 18 | 18 | ||
| 19 | » private·void·OnSceneLoaded(Scene·scene,·LoadSceneMode·mode) | 19 | » private·void·OnSceneLoaded(Scene·scene,·LoadSceneMode·mode) |
| 20 | » { | 20 | » { |
| 21 | » » this.showInScene·=·scene.name·==·" | 21 | » » this.showInScene·=·scene.name·==·"OnlineGame"; |
| 22 | » » if·(scene.name·==·"OnlineGame") | 22 | » » if·(scene.name·==·"OnlineGame") |
| 23 | » » { | 23 | » » { |
| 24 | » » » this.Tab.SetActive(false); | ||
| 25 | » » » this.NormalCollider.enabled·=·true; | ||
| 26 | » » » this.TabCollider.enabled·=·false; | ||
| 27 | » » » base.gameObject.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform); | 24 | » » » base.gameObject.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform); |
| 28 | » » » DestroyableSingleton<FriendsListManager>.Instance.Ui.gameObject.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform); | 25 | » » » DestroyableSingleton<FriendsListManager>.Instance.Ui.gameObject.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform); |
| 29 | » » » DestroyableSingleton<FriendsListManager>.Instance.ConfirmationScreen.gameObject.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform); | 26 | » » » DestroyableSingleton<FriendsListManager>.Instance.ConfirmationScreen.gameObject.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform); |
| 30 | » » » this.AspectPosition.DistanceFromEdge·=·this.LobbyPosition; | ||
| 31 | » » » this.AspectPosition.Alignment·=·AspectPosition.EdgeAlignments.RightTop; | ||
| 32 | » » } | ||
| 33 | » » else | ||
| 34 | » » { | ||
| 35 | » » » this.NormalCollider.enabled·=·false; | ||
| 36 | » » » this.TabCollider.enabled·=·true; | ||
| 37 | » » » this.Tab.SetActive(true); | ||
| 38 | » » » this.AspectPosition.DistanceFromEdge·=·this.NormalPosition; | ||
| 39 | » » » this.AspectPosition.Alignment·=·AspectPosition.EdgeAlignments.LeftTop; | ||
| 40 | » » } | 27 | » » } |
| 41 | » » base.gameObject.transform.position·=·Vector3.zero; | 28 | » » base.gameObject.transform.position·=·Vector3.zero; |
| 42 | » } | 29 | » } |
| 43 | 30 | ||
| 44 | » private·void·Update() | 31 | » private·void·Update() |
| 45 | » { | 32 | » { |
| 46 | » » if·(DataManager.Player.Account.LoginStatus·==·EOSManager.AccountLoginStatus.Offline·||·!this.showInScene·||·ShipStatus.Instance·!=·null) | 33 | » » if·(DataManager.Player.Account.LoginStatus·==·EOSManager.AccountLoginStatus.Offline·||·!this.showInScene·||·ShipStatus.Instance·!=·null) |
| Offset 71, 28 lines modified | Offset 58, 16 lines modified | ||
| 71 | » » » return; | 58 | » » » return; |
| 72 | » » } | 59 | » » } |
| 73 | » » this.gamepadButton.SetColor(Palette.EnabledColor); | 60 | » » this.gamepadButton.SetColor(Palette.EnabledColor); |
| 74 | » } | 61 | » } |
| 75 | 62 | ||
| 76 | » public·GameObject·Button; | 63 | » public·GameObject·Button; |
| 77 | 64 | ||
| 78 | » public·AspectPosition·AspectPosition; | ||
| 79 | |||
| 80 | » public·Vector3·NormalPosition; | ||
| 81 | |||
| 82 | » public·Vector3·LobbyPosition; | ||
| 83 | |||
| 84 | » public·TextMeshPro·NotifCount; | 65 | » public·TextMeshPro·NotifCount; |
| 85 | 66 | ||
| 86 | » public·GameObject·NotifCircle; | 67 | » public·GameObject·NotifCircle; |
| 87 | 68 | ||
| 88 | » public·GameObject·Tab; | ||
| 89 | |||
| 90 | » public·Collider2D·TabCollider; | ||
| 91 | |||
| 92 | » public·Collider2D·NormalCollider; | ||
| 93 | |||
| 94 | » [SerializeField] | 69 | » [SerializeField] |
| 95 | » private·ActionMapGlyphDisplay·gamepadButton; | 70 | » private·ActionMapGlyphDisplay·gamepadButton; |
| 96 | 71 | ||
| 97 | » private·bool·showInScene; | 72 | » private·bool·showInScene; |
| 98 | } | 73 | } |
| Offset 234, 45 lines modified | Offset 234, 49 lines modified | ||
| 234 | » » if·(this.pollingRoutine·!=·null) | 234 | » » if·(this.pollingRoutine·!=·null) |
| 235 | » » { | 235 | » » { |
| 236 | » » » base.StopCoroutine(this.pollingRoutine); | 236 | » » » base.StopCoroutine(this.pollingRoutine); |
| 237 | » » » this.pollingRoutine·=·null; | 237 | » » » this.pollingRoutine·=·null; |
| 238 | » » } | 238 | » » } |
| 239 | » } | 239 | » } |
| 240 | 240 | ||
| 241 | » public·void·SetRecentlyPlayed(List< | 241 | » public·void·SetRecentlyPlayed(List<NetworkedPlayerInfo>·players) |
| 242 | » { | 242 | » { |
| 243 | » » this.RecentlyPlayedWith·=· | 243 | » » this.RecentlyPlayedWith·=·new·List<FriendsListManager.RecentPlayedWithPlayer>(); |
| 244 | » » foreach·(NetworkedPlayerInfo·networkedPlayerInfo·in·players) | ||
| 245 | » » { | ||
| 246 | » » » this.RecentlyPlayedWith.Add(new·FriendsListManager.RecentPlayedWithPlayer(networkedPlayerInfo)); | ||
| 247 | » » } | ||
| 244 | » » this.UpdateFriendsDataWithPlayers(players); | 248 | » » this.UpdateFriendsDataWithPlayers(players); |
| 245 | » } | 249 | » } |
| 246 | 250 | ||
| 247 | » public·void·UpdateFriendsDataWithPlayers(List< | 251 | » public·void·UpdateFriendsDataWithPlayers(List<NetworkedPlayerInfo>·players) |
| 248 | » { | 252 | » { |
| 249 | » » if·(players·==·null·||·players.Count·==·0) | 253 | » » if·(players·==·null·||·players.Count·==·0) |
| 250 | » » { | 254 | » » { |
| 251 | » » » return; | 255 | » » » return; |
| 252 | » » } | 256 | » » } |
| 253 | » » bool·flag·=·false; | 257 | » » bool·flag·=·false; |
| 254 | » » StringBuilder·stringBuilder·=·new·StringBuilder(string.Format("Updating·{0}·with·player·info·from·{1}·players!)",·"PlayerFriendData",·players.Count)); | 258 | » » StringBuilder·stringBuilder·=·new·StringBuilder(string.Format("Updating·{0}·with·player·info·from·{1}·players!)",·"PlayerFriendData",·players.Count)); |
| 255 | » » foreach·( | 259 | » » foreach·(NetworkedPlayerInfo·networkedPlayerInfo·in·players) |
| 256 | » » { | 260 | » » { |
| 257 | » » » if·( | 261 | » » » if·(networkedPlayerInfo·==·null·||·string.IsNullOrWhiteSpace(networkedPlayerInfo.PlayerName)·||·string.IsNullOrWhiteSpace(networkedPlayerInfo.Puid)·||·networkedPlayerInfo.IsIncomplete) |
| 258 | » » » { | 262 | » » » { |
| 259 | » » » » stringBuilder.AppendLine("·-·Player·"·+·"[Uninitialized]".Color(Palette.LogErrorColor)); | 263 | » » » » stringBuilder.AppendLine("·-·Player·"·+·"[Uninitialized]".Color(Palette.LogErrorColor)); |
| 260 | » » » } | 264 | » » » } |
| 261 | » » » else | 265 | » » » else |
| 262 | » » » { | 266 | » » » { |
| 263 | » » » » stringBuilder.AppendLine(string.Concat(new·string[]·{·"·-·",· | 267 | » » » » stringBuilder.AppendLine(string.Concat(new·string[]·{·"·-·",·networkedPlayerInfo.PlayerName,·"·(PUID:·",·networkedPlayerInfo.Puid,·")·"·})); |
| 264 | » » » » if·(this.IsPlayerFriend( | 268 | » » » » if·(this.IsPlayerFriend(networkedPlayerInfo.Puid)) |
| 265 | » » » » { | 269 | » » » » { |
| 266 | » » » » » stringBuilder.Append("[Friend]·".Color(Palette.LogSuccessColor)); | 270 | » » » » » stringBuilder.Append("[Friend]·".Color(Palette.LogSuccessColor)); |
| 267 | » » » » » string·cachedName·=·DataManager.Player.Friends.GetCachedName( | 271 | » » » » » string·cachedName·=·DataManager.Player.Friends.GetCachedName(networkedPlayerInfo.Puid); |
| 268 | » » » » » if·(string.IsNullOrWhiteSpace(cachedName)·||·cachedName·!=· | 272 | » » » » » if·(string.IsNullOrWhiteSpace(cachedName)·||·cachedName·!=·networkedPlayerInfo.PlayerName) |
| 269 | » » » » » { | 273 | » » » » » { |
| 270 | » » » » » » stringBuilder.Append("[Cached·new·name]".Color(Palette.LogWarningColor)); | 274 | » » » » » » stringBuilder.Append("[Cached·new·name]".Color(Palette.LogWarningColor)); |
| 271 | » » » » » » DataManager.Player.Friends.UpdateCachedName( | 275 | » » » » » » DataManager.Player.Friends.UpdateCachedName(networkedPlayerInfo.Puid,·networkedPlayerInfo.PlayerName); |
| 272 | » » » » » » flag·=·true; | 276 | » » » » » » flag·=·true; |
| 273 | » » » » » } | 277 | » » » » » } |
| 274 | » » » » } | 278 | » » » » } |
| 275 | » » » } | 279 | » » » } |
| 276 | » » } | 280 | » » } |
| 277 | » » if·(flag) | 281 | » » if·(flag) |
| 278 | » » { | 282 | » » { |
| Offset 301, 14 lines modified | Offset 305, 40 lines modified | ||
| 301 | » } | 305 | » } |
| 302 | 306 | ||
| 303 | » public·void·OpenUi() | 307 | » public·void·OpenUi() |
| 304 | » { | 308 | » { |
| 305 | » » this.Ui.Open(); | 309 | » » this.Ui.Open(); |
| 306 | » } | 310 | » } |
| 307 | 311 | ||
| 312 | » public·void·CloseUI() | ||
| 313 | » { | ||
| 314 | » » if·(this.Ui·&&·this.Ui.gameObject.activeSelf) | ||
| 315 | » » { | ||
| 316 | » » » this.Ui.Close(true); | ||
| 317 | » » } | ||
| 318 | » } | ||
| 319 | |||
| 320 | » public·void·JoinGameViaFriendInvite(string·roomCode) | ||
| 321 | » { | ||
| 322 | » » base.StartCoroutine(this.CoJoinGameViaFriendInvite(roomCode)); | ||
| 323 | » } | ||
| 324 | |||
| 325 | » private·IEnumerator·CoJoinGameViaFriendInvite(string·roomCode) | ||
| 326 | » { | ||
| 327 | » » this.LoadScreen.enabled·=·true; | ||
| 328 | » » if·(AmongUsClient.Instance.AmClient) | ||
| 329 | » » { | ||
| 330 | » » » AmongUsClient.Instance.ExitGame(DisconnectReasons.ExitGame); | ||
| 331 | » » } | ||
| 332 | » » int·num·=·GameCode.GameNameToInt(roomCode); | ||
| 333 | » » yield·return·AmongUsClient.Instance.CoJoinOnlineGameFromCode(num); | ||
| 334 | » » this.LoadScreen.enabled·=·false; | ||
| 335 | » » yield·break; | ||
| 336 | » } | ||
| 337 | |||
| 308 | » public·IEnumerator·CheckFriendCodeOnLogin() | 338 | » public·IEnumerator·CheckFriendCodeOnLogin() |
| 309 | » { | 339 | » { |
| 310 | » » if·(DataManager.Player.Account.LoginStatus·==·EOSManager.AccountLoginStatus.LoggedIn) | 340 | » » if·(DataManager.Player.Account.LoginStatus·==·EOSManager.AccountLoginStatus.LoggedIn) |
| 311 | » » { | 341 | » » { |
| 312 | » » » yield·return·base.StartCoroutine(DestroyableSingleton<FriendsListManager>.Instance.GetFriendCode(delegate(ResponseState·cb,·Response<ResponseFriendCode>·response) | 342 | » » » yield·return·base.StartCoroutine(DestroyableSingleton<FriendsListManager>.Instance.GetFriendCode(delegate(ResponseState·cb,·Response<ResponseFriendCode>·response) |
| 313 | » » » { | 343 | » » » { |
| 314 | » » » » if·(cb·==·ResponseState.Success) | 344 | » » » » if·(cb·==·ResponseState.Success) |
| Offset 388, 15 lines modified | Offset 418, 15 lines modified | ||
| 388 | » » base.StartCoroutine(this.ConfirmationScreen.WaitForConfirm(confirm,·type,·recipientFriendCode)); | 418 | » » base.StartCoroutine(this.ConfirmationScreen.WaitForConfirm(confirm,·type,·recipientFriendCode)); |
| 389 | » } | 419 | » } |
| 390 | 420 | ||
| 391 | » private·IEnumerator·PollForRequests() | 421 | » private·IEnumerator·PollForRequests() |
| 392 | » { | 422 | » { |
| 393 | » » for·(;;) | 423 | » » for·(;;) |
| 394 | » » { | 424 | » » { |
| 395 | » » » FriendsListManager.<>c__DisplayClass5 | 425 | » » » FriendsListManager.<>c__DisplayClass55_0·CS$<>8__locals1·=·new·FriendsListManager.<>c__DisplayClass55_0(); |
| 396 | » » » CS$<>8__locals1.<>4__this·=·this; | 426 | » » » CS$<>8__locals1.<>4__this·=·this; |
| 397 | » » » while·(!DataManager.Settings.Multiplayer.AllowFriendInvites) | 427 | » » » while·(!DataManager.Settings.Multiplayer.AllowFriendInvites) |
| 398 | » » » { | 428 | » » » { |
| 399 | » » » » yield·return·null; | 429 | » » » » yield·return·null; |
| 400 | » » » } | 430 | » » » } |
| 401 | » » » this.gotFriendRequests·=·false; | 431 | » » » this.gotFriendRequests·=·false; |
| 402 | » » » this.gotLobbyInvites·=·false; | 432 | » » » this.gotLobbyInvites·=·false; |
| Offset 849, 15 lines modified | Offset 879, 15 lines modified | ||
| 849 | 879 | ||
| 850 | » public·List<ResponseBlockedBy>·BlockedByPlayers·=·new·List<ResponseBlockedBy>(); | 880 | » public·List<ResponseBlockedBy>·BlockedByPlayers·=·new·List<ResponseBlockedBy>(); |
| 851 | 881 | ||
| 852 | » public·List<ResponseReceivedFriendRequest>·ReceivedRequests·=·new·List<ResponseReceivedFriendRequest>(); | 882 | » public·List<ResponseReceivedFriendRequest>·ReceivedRequests·=·new·List<ResponseReceivedFriendRequest>(); |
| 853 | 883 | ||
| 854 | » public·List<LobbyInvite>·ReceivedLobbyInvites·=·new·List<LobbyInvite>(); | 884 | » public·List<LobbyInvite>·ReceivedLobbyInvites·=·new·List<LobbyInvite>(); |
| 855 | 885 | ||
| 856 | » public·List< | 886 | » public·List<FriendsListManager.RecentPlayedWithPlayer>·RecentlyPlayedWith·=·new·List<FriendsListManager.RecentPlayedWithPlayer>(); |
| 857 | 887 | ||
| 858 | » public·FriendListNotification·FriendListNotification; | 888 | » public·FriendListNotification·FriendListNotification; |
| 859 | 889 | ||
| 860 | » public·FriendsListConfirmMenu·ConfirmationScreen; | 890 | » public·FriendsListConfirmMenu·ConfirmationScreen; |
| 861 | 891 | ||
| 862 | » public·FriendsListUI·Ui; | 892 | » public·FriendsListUI·Ui; |
| 863 | 893 | ||
| Offset 945, 8 lines modified | Offset 975, 24 lines modified | ||
| 945 | 975 | ||
| 946 | » » public·string·Username; | 976 | » » public·string·Username; |
| 947 | 977 | ||
| 948 | » » public·ulong·GUID; | 978 | » » public·ulong·GUID; |
| Max diff block lines reached; 399/5774 bytes (6.91%) of diff not shown. | |||
| Offset 389, 15 lines modified | Offset 389, 15 lines modified | ||
| 389 | » » if·(GameData.Instance·==·null·||·GameData.Instance.AllPlayers.Count·==·0) | 389 | » » if·(GameData.Instance·==·null·||·GameData.Instance.AllPlayers.Count·==·0) |
| 390 | » » { | 390 | » » { |
| 391 | » » » return; | 391 | » » » return; |
| 392 | » » } | 392 | » » } |
| 393 | » » int·num·=·0; | 393 | » » int·num·=·0; |
| 394 | » » for·(int·i·=·0;·i·<·GameData.Instance.AllPlayers.Count;·i++) | 394 | » » for·(int·i·=·0;·i·<·GameData.Instance.AllPlayers.Count;·i++) |
| 395 | » » { | 395 | » » { |
| 396 | » » » | 396 | » » » NetworkedPlayerInfo·player·=·GameData.Instance.AllPlayers[i]; |
| 397 | » » » if·(player.PlayerId·!=·PlayerControl.LocalPlayer.PlayerId) | 397 | » » » if·(player.PlayerId·!=·PlayerControl.LocalPlayer.PlayerId) |
| 398 | » » » { | 398 | » » » { |
| 399 | » » » » float·num2·=·this.YStart·-·(float)num·*·this.YOffset; | 399 | » » » » float·num2·=·this.YStart·-·(float)num·*·this.YOffset; |
| 400 | » » » » LobbyPlayerBar·lobbyPlayerBar·=·Object.Instantiate<LobbyPlayerBar>(this.LobbyPlayerBar,·this.LobbyPlayerArea.transform); | 400 | » » » » LobbyPlayerBar·lobbyPlayerBar·=·Object.Instantiate<LobbyPlayerBar>(this.LobbyPlayerBar,·this.LobbyPlayerArea.transform); |
| 401 | » » » » lobbyPlayerBar.SetUp(player.Puid,·this,·player.FriendCode,·player.PlayerName); | 401 | » » » » lobbyPlayerBar.SetUp(player.Puid,·this,·player.FriendCode,·player.PlayerName); |
| 402 | » » » » lobbyPlayerBar.transform.localPosition·=·new·Vector3(-0.29f,·num2,·-1f); | 402 | » » » » lobbyPlayerBar.transform.localPosition·=·new·Vector3(-0.29f,·num2,·-1f); |
| 403 | » » » » lobbyPlayerBar.Buttons.ForEach(delegate(PassiveButton·b) | 403 | » » » » lobbyPlayerBar.Buttons.ForEach(delegate(PassiveButton·b) |
| Offset 429, 20 lines modified | Offset 429, 20 lines modified | ||
| 429 | » } | 429 | » } |
| 430 | 430 | ||
| 431 | » public·void·RefreshRecentlyPlayed() | 431 | » public·void·RefreshRecentlyPlayed() |
| 432 | » { | 432 | » { |
| 433 | » » int·num·=·0; | 433 | » » int·num·=·0; |
| 434 | » » for·(int·i·=·0;·i·<·DestroyableSingleton<FriendsListManager>.Instance.RecentlyPlayedWith.Count;·i++) | 434 | » » for·(int·i·=·0;·i·<·DestroyableSingleton<FriendsListManager>.Instance.RecentlyPlayedWith.Count;·i++) |
| 435 | » » { | 435 | » » { |
| 436 | » » » | 436 | » » » FriendsListManager.RecentPlayedWithPlayer·recentPlayedWithPlayer·=·DestroyableSingleton<FriendsListManager>.Instance.RecentlyPlayedWith[i]; |
| 437 | » » » if·(!( | 437 | » » » if·(!(recentPlayedWithPlayer.PlayerName·==·DataManager.Player.Customization.Name)) |
| 438 | » » » { | 438 | » » » { |
| 439 | » » » » float·num2·=·this.YStart·-·(float)num·*·this.YOffset; | 439 | » » » » float·num2·=·this.YStart·-·(float)num·*·this.YOffset; |
| 440 | » » » » LobbyPlayerBar·lobbyPlayerBar·=·Object.Instantiate<LobbyPlayerBar>(this.LobbyPlayerBar,·this.RecentlyPlayedArea.transform); | 440 | » » » » LobbyPlayerBar·lobbyPlayerBar·=·Object.Instantiate<LobbyPlayerBar>(this.LobbyPlayerBar,·this.RecentlyPlayedArea.transform); |
| 441 | » » » » lobbyPlayerBar.SetUp( | 441 | » » » » lobbyPlayerBar.SetUp(recentPlayedWithPlayer.Puid,·this,·recentPlayedWithPlayer.FriendCode,·recentPlayedWithPlayer.PlayerName); |
| 442 | » » » » lobbyPlayerBar.transform.localPosition·=·new·Vector3(-0.29f,·num2,·-1f); | 442 | » » » » lobbyPlayerBar.transform.localPosition·=·new·Vector3(-0.29f,·num2,·-1f); |
| 443 | » » » » lobbyPlayerBar.Buttons.ForEach(delegate(PassiveButton·b) | 443 | » » » » lobbyPlayerBar.Buttons.ForEach(delegate(PassiveButton·b) |
| 444 | » » » » { | 444 | » » » » { |
| 445 | » » » » » b.ClickMask·=·this.RecentlyPlayedScroller.Hitbox; | 445 | » » » » » b.ClickMask·=·this.RecentlyPlayedScroller.Hitbox; |
| 446 | » » » » }); | 446 | » » » » }); |
| 447 | » » » » lobbyPlayerBar.GetAndSetPlatform(); | 447 | » » » » lobbyPlayerBar.GetAndSetPlatform(); |
| 448 | » » » » this.lobbyBars.Add(lobbyPlayerBar); | 448 | » » » » this.lobbyBars.Add(lobbyPlayerBar); |
| Offset 3, 47 lines modified | Offset 3, 57 lines modified | ||
| 3 | using·UnityEngine; | 3 | using·UnityEngine; |
| 4 | 4 | ||
| 5 | public·class·FungleExileController·:·ExileController | 5 | public·class·FungleExileController·:·ExileController |
| 6 | { | 6 | { |
| 7 | » protected·override·IEnumerator·Animate() | 7 | » protected·override·IEnumerator·Animate() |
| 8 | » { | 8 | » { |
| 9 | » » SoundManager.Instance.PlayNamedSound("ejection_beach_sfx",·this.ambience,·true,·SoundManager.Instance.SfxChannel); | 9 | » » SoundManager.Instance.PlayNamedSound("ejection_beach_sfx",·this.ambience,·true,·SoundManager.Instance.SfxChannel); |
| 10 | » » if·(this. | 10 | » » if·(this.initData·==·null·||·this.initData.outfit·==·null) |
| 11 | » » { | 11 | » » { |
| 12 | » » » this.Player.gameObject.SetActive(false); | 12 | » » » this.Player.gameObject.SetActive(false); |
| 13 | » » » this.raftAnimation.gameObject.SetActive(false); | 13 | » » » this.raftAnimation.gameObject.SetActive(false); |
| 14 | » » } | 14 | » » } |
| 15 | » » if·(this. | 15 | » » if·(this.initData·!=·null·&&·this.initData.outfit·!=·null·&&·this.EjectSound) |
| 16 | » » { | 16 | » » { |
| 17 | » » » SoundManager.Instance.PlaySound(this.EjectSound,·false,·1f,·SoundManager.Instance.SfxChannel); | 17 | » » » SoundManager.Instance.PlaySound(this.EjectSound,·false,·1f,·SoundManager.Instance.SfxChannel); |
| 18 | » » } | 18 | » » } |
| 19 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | ||
| 20 | » » { | ||
| 19 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false); | 21 | » » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false); |
| 22 | » » } | ||
| 20 | » » yield·return·Effects.Wait(0.5f); | 23 | » » yield·return·Effects.Wait(0.5f); |
| 21 | » » yield·return·Effects.All(new·IEnumerator[] | 24 | » » yield·return·Effects.All(new·IEnumerator[] |
| 22 | » » { | 25 | » » { |
| 23 | » » » this.FadeBlackRaftAndPlayer(), | 26 | » » » this.FadeBlackRaftAndPlayer(), |
| 24 | » » » this.HandleText(0.2f,·2f) | 27 | » » » this.HandleText(0.2f,·2f) |
| 25 | » » }); | 28 | » » }); |
| 26 | » » if·( | 29 | » » if·(this.initData.confirmImpostor) |
| 27 | » » { | 30 | » » { |
| 28 | » » » this.ImpostorText.gameObject.SetActive(true); | 31 | » » » this.ImpostorText.gameObject.SetActive(true); |
| 29 | » » } | 32 | » » } |
| 30 | » » yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f); | 33 | » » yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f); |
| 31 | » » yield·return·new·WaitForSeconds(2f); | 34 | » » yield·return·new·WaitForSeconds(2f); |
| 35 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | ||
| 36 | » » { | ||
| 32 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false); | 37 | » » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false); |
| 38 | » » } | ||
| 39 | » » else | ||
| 40 | » » { | ||
| 41 | » » » yield·return·Effects.Wait(0.2f); | ||
| 42 | » » } | ||
| 33 | » » SoundManager.Instance.StopNamedSound("ejection_beach_sfx"); | 43 | » » SoundManager.Instance.StopNamedSound("ejection_beach_sfx"); |
| 34 | » » SoundManager.Instance.StopNamedSound("ejection_fire_sfx"); | 44 | » » SoundManager.Instance.StopNamedSound("ejection_fire_sfx"); |
| 35 | » » base.WrapUp(); | 45 | » » base.WrapUp(); |
| 36 | » » yield·break; | 46 | » » yield·break; |
| 37 | » } | 47 | » } |
| 38 | 48 | ||
| 39 | » private·IEnumerator·FadeBlackRaftAndPlayer() | 49 | » private·IEnumerator·FadeBlackRaftAndPlayer() |
| 40 | » { | 50 | » { |
| 41 | » » yield·return·Effects.Wait(1f); | 51 | » » yield·return·Effects.Wait(1f); |
| 42 | » » if·(this. | 52 | » » if·(this.initData·!=·null·&&·this.initData.outfit·!=·null) |
| 43 | » » { | 53 | » » { |
| 44 | » » » this.Player.FadeBlackAll(1.5f); | 54 | » » » this.Player.FadeBlackAll(1.5f); |
| 45 | » » » yield·return·Effects.ColorFade(this.raftSprite,·Color.white,·Color.black,·1.5f); | 55 | » » » yield·return·Effects.ColorFade(this.raftSprite,·Color.white,·Color.black,·1.5f); |
| 46 | » » » this.fire.gameObject.SetActive(true); | 56 | » » » this.fire.gameObject.SetActive(true); |
| 47 | » » » SoundManager.Instance.PlayNamedSound("ejection_fire_sfx",·this.fireSound,·true,·SoundManager.Instance.SfxChannel); | 57 | » » » SoundManager.Instance.PlayNamedSound("ejection_fire_sfx",·this.fireSound,·true,·SoundManager.Instance.SfxChannel); |
| 48 | » » » VibrationManager.Vibrate(0.2f,·0.2f,·2.4f,·VibrationManager.VibrationFalloff.Linear,·null,·false,·""); | 58 | » » » VibrationManager.Vibrate(0.2f,·0.2f,·2.4f,·VibrationManager.VibrationFalloff.Linear,·null,·false,·""); |
| 49 | » » } | 59 | » » } |
| Offset 125, 16 lines modified | Offset 125, 16 lines modified | ||
| 125 | 125 | ||
| 126 | » [SerializeField] | 126 | » [SerializeField] |
| 127 | » private·Vector3·initialOffset; | 127 | » private·Vector3·initialOffset; |
| 128 | 128 | ||
| 129 | » [SerializeField] | 129 | » [SerializeField] |
| 130 | » private·float·cameraOrthographicSize; | 130 | » private·float·cameraOrthographicSize; |
| 131 | 131 | ||
| 132 | » [SerializeField] | ||
| 133 | » [Header("Speeds")] | 132 | » [Header("Speeds")] |
| 133 | » [SerializeField] | ||
| 134 | » private·float·keyboardMoveSpeed; | 134 | » private·float·keyboardMoveSpeed; |
| 135 | 135 | ||
| 136 | » [SerializeField] | 136 | » [SerializeField] |
| 137 | » private·float·buttonMoveSpeed; | 137 | » private·float·buttonMoveSpeed; |
| 138 | 138 | ||
| 139 | » [SerializeField] | 139 | » [SerializeField] |
| 140 | » private·float·joystickMoveSpeed; | 140 | » private·float·joystickMoveSpeed; |
| Offset 1, 131 lines modified | Offset 1, 56 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections.Generic; | 2 | using·System.Collections.Generic; |
| 3 | using·System.Linq; | 3 | using·System.Linq; |
| 4 | using·AmongUs.GameOptions; | ||
| 5 | using·Beebyte.Obfuscator; | 4 | using·Beebyte.Obfuscator; |
| 6 | using·Hazel; | ||
| 7 | using·InnerNet; | 5 | using·InnerNet; |
| 8 | using·UnityEngine; | 6 | using·UnityEngine; |
| 9 | 7 | ||
| 10 | [SkipRename] | 8 | [SkipRename] |
| 11 | public·class·GameData·:· | 9 | public·class·GameData·:·MonoBehaviour,·IDisconnectHandler |
| 12 | { | 10 | { |
| 13 | » public· | 11 | » public·int·PlayerCount |
| 14 | » { | 12 | » { |
| 15 | » » | 13 | » » get |
| 16 | » » { | 14 | » » { |
| 17 | » » » | 15 | » » » return·this.AllPlayers.Count; |
| 18 | » » } | 16 | » » } |
| 19 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·29,·SendOption.Reliable); | ||
| 20 | » » messageWriter.Write(playerId); | ||
| 21 | » » messageWriter.WriteBytesAndSize(taskTypeIds); | ||
| 22 | » » messageWriter.EndMessage(); | ||
| 23 | » } | 17 | » } |
| 24 | 18 | ||
| 25 | » public· | 19 | » public·bool·IsPersistent |
| 26 | » { | 20 | » { |
| 21 | » » get | ||
| 27 | » » List<GameData.PlayerInfo>·list·=·Enumerable.ToList<GameData.PlayerInfo>(Enumerable.OrderBy<GameData.PlayerInfo,·int>(this.AllPlayers,·delegate(GameData.PlayerInfo·p) | ||
| 28 | » » { | ||
| 29 | » » » if·(!string.IsNullOrWhiteSpace(p.PlayerName)) | ||
| 30 | » » » { | ||
| 31 | » » » » return·1; | ||
| 32 | » » » } | ||
| 33 | » » » return·0; | ||
| 34 | » » })); | ||
| 35 | » » int·num·=·0; | ||
| 36 | » » for·(int·i·=·0;·i·<·list.Count;·i++) | ||
| 37 | » » { | ||
| 38 | » » » GameData.PlayerInfo·playerInfo·=·list[i]; | ||
| 39 | » » » if·(initialState·||·base.IsDirtyBitSet((int)playerInfo.PlayerId)) | ||
| 40 | » » » { | ||
| 41 | » » » » if·(!initialState) | ||
| 42 | » » » » { | ||
| 43 | » » » » » base.UnsetDirtyBit(1U·<<·(int)playerInfo.PlayerId); | ||
| 44 | » » » » } | ||
| 45 | » » » » writer.StartMessage(playerInfo.PlayerId); | ||
| 46 | » » » » playerInfo.Serialize(writer); | ||
| 47 | » » » » writer.EndMessage(); | ||
| 48 | » » » » if·(++num·>·4) | ||
| 49 | » » » » { | ||
| 50 | » » » » » if·(initialState) | ||
| 51 | » » » » » { | ||
| 52 | » » » » » » for·(int·j·=·i·+·1;·j·<·list.Count;·j++) | ||
| 53 | » » » » » » { | ||
| 54 | » » » » » » » GameData.PlayerInfo·playerInfo2·=·list[j]; | ||
| 55 | » » » » » » » base.SetDirtyBit(1U·<<·(int)playerInfo2.PlayerId); | ||
| 56 | » » » » » » } | ||
| 57 | » » » » » » break; | ||
| 58 | » » » » » } | ||
| 59 | » » » » » break; | ||
| 60 | » » » » } | ||
| 61 | » » » } | ||
| 62 | » » } | ||
| 63 | » » if·(num·==·0) | ||
| 64 | » » { | 22 | » » { |
| 65 | » » » base.ClearDirtyBits(); | ||
| 66 | » » » return· | 23 | » » » return·true; |
| 67 | » » } | 24 | » » } |
| 68 | » » return·true; | ||
| 69 | » } | 25 | » } |
| 70 | 26 | ||
| 71 | » public· | 27 | » public·static·void·DestroyInstance() |
| 72 | » { | 28 | » { |
| 29 | » » if·(GameData.Instance·!=·null) | ||
| 73 | » » while·(reader.Position·<·reader.Length) | ||
| 74 | » » { | ||
| 75 | » » » MessageReader·messageReader·=·reader.ReadMessage(); | ||
| 76 | » » » GameData.PlayerInfo·playerInfo·=·this.GetPlayerById(messageReader.Tag); | ||
| 77 | » » » if·(playerInfo·!=·null) | ||
| 78 | » » » { | ||
| 79 | » » » » playerInfo.Deserialize(messageReader); | ||
| 80 | » » » } | ||
| 81 | » » » else | ||
| 82 | » » » { | ||
| 83 | » » » » playerInfo·=·new·GameData.PlayerInfo(messageReader.Tag); | ||
| 84 | » » » » playerInfo.Deserialize(messageReader); | ||
| 85 | » » » » this.AllPlayers.Add(playerInfo); | ||
| 86 | » » » } | ||
| 87 | » » } | ||
| 88 | » » foreach·(GameData.PlayerInfo·playerInfo2·in·this.AllPlayers) | ||
| 89 | » » { | 30 | » » { |
| 31 | » » » Object.Destroy(GameData.Instance.gameObject); | ||
| 90 | » » » ClientData·clientFromCharacter·=·AmongUsClient.Instance.GetClientFromCharacter(playerInfo2.Object); | ||
| 91 | » » » if·(clientFromCharacter·!=·null) | ||
| 92 | » » » { | ||
| 93 | » » » » clientFromCharacter.UpdatePlayerName(playerInfo2.GetPlayerName(PlayerOutfitType.Default)); | ||
| 94 | » » » } | ||
| 95 | » » » if·(!playerInfo2.Role) | ||
| 96 | » » » { | ||
| 97 | » » » » DestroyableSingleton<RoleManager>.Instance.SetRole(playerInfo2.Object,·playerInfo2.RoleType); | ||
| 98 | » » » } | ||
| 99 | » » } | 32 | » » } |
| 100 | » » this.RecomputeTaskCounts(); | ||
| 101 | » } | 33 | » } |
| 102 | 34 | ||
| 103 | » public· | 35 | » public·static·void·OnMeetingStart() |
| 104 | » { | 36 | » { |
| 37 | » » GameData.MeetingCount++; | ||
| 105 | » » if·(callId·==·29) | ||
| 106 | » » { | ||
| 107 | » » » this.SetTasks(reader.ReadByte(),·reader.ReadBytesAndSize()); | ||
| 108 | » » } | ||
| 109 | » } | 38 | » } |
| 110 | 39 | ||
| 111 | » public· | 40 | » public·static·void·OnGameEnd() |
| 112 | » { | 41 | » { |
| 42 | » » GameData.RoundsPlayedInSession++; | ||
| 43 | » » GameData.MeetingCount·=·0; | ||
| 44 | » » EndGameResult.ResetCachedValues(); | ||
| 113 | » » get | ||
| 114 | » » { | ||
| 115 | » » » return·true; | ||
| 116 | » » } | ||
| 117 | » } | 45 | » } |
| 118 | 46 | ||
| 119 | » public· | 47 | » public·static·void·OnDisconnected() |
| 120 | » { | 48 | » { |
| Max diff block lines reached; 24135/27978 bytes (86.26%) of diff not shown. | |||
| Offset 56, 15 lines modified | Offset 56, 18 lines modified | ||
| 56 | » » » » flag·=·true; | 56 | » » » » flag·=·true; |
| 57 | » » » » writer.StartMessage((byte)i); | 57 | » » » » writer.StartMessage((byte)i); |
| 58 | » » » » gameLogicComponent.Serialize(writer,·initialState); | 58 | » » » » gameLogicComponent.Serialize(writer,·initialState); |
| 59 | » » » » writer.EndMessage(); | 59 | » » » » writer.EndMessage(); |
| 60 | » » » » gameLogicComponent.ClearDirtyFlag(); | 60 | » » » » gameLogicComponent.ClearDirtyFlag(); |
| 61 | » » » } | 61 | » » » } |
| 62 | » » } | 62 | » » } |
| 63 | » » if·(!initialState) | ||
| 64 | » » { | ||
| 63 | » » base.ClearDirtyBits(); | 65 | » » » base.ClearDirtyBits(); |
| 66 | » » } | ||
| 64 | » » return·flag; | 67 | » » return·flag; |
| 65 | » } | 68 | » } |
| 66 | 69 | ||
| 67 | » public·override·void·Deserialize(MessageReader·reader,·bool·initialState) | 70 | » public·override·void·Deserialize(MessageReader·reader,·bool·initialState) |
| 68 | » { | 71 | » { |
| 69 | » » while·(reader.Position·<·reader.Length) | 72 | » » while·(reader.Position·<·reader.Length) |
| 70 | » » { | 73 | » » { |
| Offset 77, 14 lines modified | Offset 80, 22 lines modified | ||
| 77 | » » » else | 80 | » » » else |
| 78 | » » » { | 81 | » » » { |
| 79 | » » » » this.LogicComponents[tag].Deserialize(messageReader,·initialState); | 82 | » » » » this.LogicComponents[tag].Deserialize(messageReader,·initialState); |
| 80 | » » » } | 83 | » » » } |
| 81 | » » } | 84 | » » } |
| 82 | » } | 85 | » } |
| 83 | 86 | ||
| 87 | » public·GameSettingsCategoryList·GameSettingsList | ||
| 88 | » { | ||
| 89 | » » get | ||
| 90 | » » { | ||
| 91 | » » » return·this.gameSettingsList; | ||
| 92 | » » } | ||
| 93 | » } | ||
| 94 | |||
| 84 | » public·static·GameManager·Instance·{·get;·private·set;·} | 95 | » public·static·GameManager·Instance·{·get;·private·set;·} |
| 85 | 96 | ||
| 86 | » public·bool·ShouldCheckForGameEnd·{·get;·set;·} | 97 | » public·bool·ShouldCheckForGameEnd·{·get;·set;·} |
| 87 | 98 | ||
| 88 | » public·bool·GameHasStarted·{·get;·set;·} | 99 | » public·bool·GameHasStarted·{·get;·set;·} |
| 89 | 100 | ||
| 90 | » public·LogicGameFlow·LogicFlow·{·get;·protected·set;·} | 101 | » public·LogicGameFlow·LogicFlow·{·get;·protected·set;·} |
| Offset 105, 38 lines modified | Offset 116, 46 lines modified | ||
| 105 | » » } | 116 | » » } |
| 106 | » } | 117 | » } |
| 107 | 118 | ||
| 108 | » public·abstract·void·InitComponents(); | 119 | » public·abstract·void·InitComponents(); |
| 109 | 120 | ||
| 110 | » public·abstract·PlayerBodyTypes·GetBodyType(PlayerControl·player); | 121 | » public·abstract·PlayerBodyTypes·GetBodyType(PlayerControl·player); |
| 111 | 122 | ||
| 123 | » public·bool·IsPersistent | ||
| 124 | » { | ||
| 125 | » » get | ||
| 126 | » » { | ||
| 127 | » » » return·false; | ||
| 128 | » » } | ||
| 129 | » } | ||
| 130 | |||
| 112 | » public·virtual·void·StartGame() | 131 | » public·virtual·void·StartGame() |
| 113 | » { | 132 | » { |
| 114 | » » foreach·(GameLogicComponent·gameLogicComponent·in·this.LogicComponents) | 133 | » » foreach·(GameLogicComponent·gameLogicComponent·in·this.LogicComponents) |
| 115 | » » { | 134 | » » { |
| 116 | » » » gameLogicComponent.OnGameStart(); | 135 | » » » gameLogicComponent.OnGameStart(); |
| 117 | » » } | 136 | » » } |
| 118 | » » this.ShouldCheckForGameEnd·=·true; | 137 | » » this.ShouldCheckForGameEnd·=·true; |
| 119 | » » this.GameHasStarted·=·true; | 138 | » » this.GameHasStarted·=·true; |
| 120 | » » foreach·( | 139 | » » foreach·(NetworkedPlayerInfo·networkedPlayerInfo·in·GameData.Instance.AllPlayers) |
| 121 | » » { | 140 | » » { |
| 122 | » » » | 141 | » » » networkedPlayerInfo.OnGameStart(); |
| 123 | » » } | 142 | » » } |
| 124 | » » DestroyableSingleton<HudManager>.Instance.OnGameStart(); | 143 | » » DestroyableSingleton<HudManager>.Instance.OnGameStart(); |
| 125 | » } | 144 | » } |
| 126 | 145 | ||
| 127 | » public·virtual·void·EndGame() | 146 | » public·virtual·void·EndGame() |
| 128 | » { | 147 | » { |
| 129 | » » foreach·(GameLogicComponent·gameLogicComponent·in·this.LogicComponents) | 148 | » » foreach·(GameLogicComponent·gameLogicComponent·in·this.LogicComponents) |
| 130 | » » { | 149 | » » { |
| 131 | » » » gameLogicComponent.OnGameEnd(); | 150 | » » » gameLogicComponent.OnGameEnd(); |
| 132 | » » } | 151 | » » } |
| 133 | » » foreach·( | 152 | » » foreach·(NetworkedPlayerInfo·networkedPlayerInfo·in·GameData.Instance.AllPlayers) |
| 134 | » » { | 153 | » » { |
| 135 | » » » | 154 | » » » networkedPlayerInfo.OnGameEnd(); |
| 136 | » » } | 155 | » » } |
| 137 | » » this.ShouldCheckForGameEnd·=·false; | 156 | » » this.ShouldCheckForGameEnd·=·false; |
| 138 | » » this.GameHasStarted·=·false; | 157 | » » this.GameHasStarted·=·false; |
| 139 | » } | 158 | » } |
| 140 | 159 | ||
| 141 | » public·virtual·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole) | 160 | » public·virtual·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole) |
| 142 | » { | 161 | » { |
| Offset 155, 14 lines modified | Offset 174, 35 lines modified | ||
| 155 | » » » Object.Destroy(base.gameObject); | 174 | » » » Object.Destroy(base.gameObject); |
| 156 | » » » return; | 175 | » » » return; |
| 157 | » » } | 176 | » » } |
| 158 | » » GameManager.Instance·=·this; | 177 | » » GameManager.Instance·=·this; |
| 159 | » » Object.DontDestroyOnLoad(base.gameObject); | 178 | » » Object.DontDestroyOnLoad(base.gameObject); |
| 160 | » » AmongUsClient.Instance.DisconnectHandlers.AddUnique(this); | 179 | » » AmongUsClient.Instance.DisconnectHandlers.AddUnique(this); |
| 161 | » » this.InitComponents(); | 180 | » » this.InitComponents(); |
| 181 | » » this.AllGameSettingData·=·new·Dictionary<StringNames,·BaseGameSetting>(); | ||
| 182 | » » foreach·(RulesCategory·rulesCategory·in·this.gameSettingsList.AllCategories) | ||
| 183 | » » { | ||
| 184 | » » » foreach·(BaseGameSetting·baseGameSetting·in·rulesCategory.AllGameSettings) | ||
| 185 | » » » { | ||
| 186 | » » » » if·(!this.AllGameSettingData.ContainsKey(baseGameSetting.Title)) | ||
| 187 | » » » » { | ||
| 188 | » » » » » this.AllGameSettingData.Add(baseGameSetting.Title,·baseGameSetting); | ||
| 189 | » » » » } | ||
| 190 | » » » } | ||
| 191 | » » } | ||
| 192 | » » foreach·(RoleRulesCategory·roleRulesCategory·in·this.gameSettingsList.AllRoles) | ||
| 193 | » » { | ||
| 194 | » » » foreach·(BaseGameSetting·baseGameSetting2·in·roleRulesCategory.AllGameSettings) | ||
| 195 | » » » { | ||
| 196 | » » » » if·(!this.AllGameSettingData.ContainsKey(baseGameSetting2.Title)) | ||
| 197 | » » » » { | ||
| 198 | » » » » » this.AllGameSettingData.Add(baseGameSetting2.Title,·baseGameSetting2); | ||
| 199 | » » » » } | ||
| 200 | » » » } | ||
| 201 | » » } | ||
| 162 | » } | 202 | » } |
| 163 | 203 | ||
| 164 | » public·bool·CheckTaskCompletion() | 204 | » public·bool·CheckTaskCompletion() |
| 165 | » { | 205 | » { |
| 166 | » » if·(DestroyableSingleton<TutorialManager>.InstanceExists) | 206 | » » if·(DestroyableSingleton<TutorialManager>.InstanceExists) |
| 167 | » » { | 207 | » » { |
| 168 | » » » if·(Enumerable.All<PlayerTask>(PlayerControl.LocalPlayer.myTasks,·(PlayerTask·t)·=>·t.IsComplete)) | 208 | » » » if·(Enumerable.All<PlayerTask>(PlayerControl.LocalPlayer.myTasks,·(PlayerTask·t)·=>·t.IsComplete)) |
| Offset 324, 14 lines modified | Offset 364, 26 lines modified | ||
| 324 | » » return·false; | 364 | » » return·false; |
| 325 | » } | 365 | » } |
| Max diff block lines reached; 742/4346 bytes (17.07%) of diff not shown. | |||
| Offset 13, 14 lines modified | Offset 13, 19 lines modified | ||
| 13 | » { | 13 | » { |
| 14 | » » get | 14 | » » get |
| 15 | » » { | 15 | » » { |
| 16 | » » » return·this.currentGameOptions·!=·null; | 16 | » » » return·this.currentGameOptions·!=·null; |
| 17 | » » } | 17 | » » } |
| 18 | » } | 18 | » } |
| 19 | 19 | ||
| 20 | » public·Type·GetGameOptions() | ||
| 21 | » { | ||
| 22 | » » return·typeof(NormalGameOptionsV08); | ||
| 23 | » } | ||
| 24 | |||
| 20 | » public·IGameOptions·CurrentGameOptions | 25 | » public·IGameOptions·CurrentGameOptions |
| 21 | » { | 26 | » { |
| 22 | » » get | 27 | » » get |
| 23 | » » { | 28 | » » { |
| 24 | » » » if·(this.currentGameOptions·==·null) | 29 | » » » if·(this.currentGameOptions·==·null) |
| 25 | » » » { | 30 | » » » { |
| 26 | » » » » this.logger.WriteError("CurrentGameOptions·was·null·on·get"); | 31 | » » » » this.logger.WriteError("CurrentGameOptions·was·null·on·get"); |
| Offset 32, 26 lines modified | Offset 37, 26 lines modified | ||
| 32 | » » { | 37 | » » { |
| 33 | » » » GameModes·gameMode·=·value.GameMode; | 38 | » » » GameModes·gameMode·=·value.GameMode; |
| 34 | » » » this.SwitchGameMode(gameMode); | 39 | » » » this.SwitchGameMode(gameMode); |
| 35 | » » » switch·(gameMode) | 40 | » » » switch·(gameMode) |
| 36 | » » » { | 41 | » » » { |
| 37 | » » » case·GameModes.Normal: | 42 | » » » case·GameModes.Normal: |
| 38 | » » » case·GameModes.NormalFools: | 43 | » » » case·GameModes.NormalFools: |
| 39 | » » » » this.currentNormalGameOptions·=·value·as·NormalGameOptionsV0 | 44 | » » » » this.currentNormalGameOptions·=·value·as·NormalGameOptionsV08; |
| 40 | » » » » if·(this.currentNormalGameOptions·==·null) | 45 | » » » » if·(this.currentNormalGameOptions·==·null) |
| 41 | » » » » { | 46 | » » » » { |
| 42 | » » » » » this.logger.WriteError(string.Format("Setting·current·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(NormalGameOptionsV0 | 47 | » » » » » this.logger.WriteError(string.Format("Setting·current·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(NormalGameOptionsV08))); |
| 43 | » » » » } | 48 | » » » » } |
| 44 | » » » » break; | 49 | » » » » break; |
| 45 | » » » case·GameModes.HideNSeek: | 50 | » » » case·GameModes.HideNSeek: |
| 46 | » » » case·GameModes.SeekFools: | 51 | » » » case·GameModes.SeekFools: |
| 47 | » » » » this.currentHideNSeekGameOptions·=·value·as·HideNSeekGameOptionsV0 | 52 | » » » » this.currentHideNSeekGameOptions·=·value·as·HideNSeekGameOptionsV08; |
| 48 | » » » » if·(this.currentHideNSeekGameOptions·==·null) | 53 | » » » » if·(this.currentHideNSeekGameOptions·==·null) |
| 49 | » » » » { | 54 | » » » » { |
| 50 | » » » » » this.logger.WriteError(string.Format("Setting·current·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(HideNSeekGameOptionsV0 | 55 | » » » » » this.logger.WriteError(string.Format("Setting·current·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(HideNSeekGameOptionsV08))); |
| 51 | » » » » } | 56 | » » » » } |
| 52 | » » » » break; | 57 | » » » » break; |
| 53 | » » » default: | 58 | » » » default: |
| 54 | » » » » this.logger.WriteError(string.Format("Cannot·cache·settings·for·game·mode·{0}",·gameMode)); | 59 | » » » » this.logger.WriteError(string.Format("Cannot·cache·settings·for·game·mode·{0}",·gameMode)); |
| 55 | » » » » break; | 60 | » » » » break; |
| 56 | » » » } | 61 | » » » } |
| 57 | » » » this.currentGameOptions·=·value; | 62 | » » » this.currentGameOptions·=·value; |
| Offset 68, 30 lines modified | Offset 73, 30 lines modified | ||
| 68 | » » { | 73 | » » { |
| 69 | » » » GameModes·gameMode·=·value.GameMode; | 74 | » » » GameModes·gameMode·=·value.GameMode; |
| 70 | » » » this.SwitchGameMode(gameMode); | 75 | » » » this.SwitchGameMode(gameMode); |
| 71 | » » » switch·(gameMode) | 76 | » » » switch·(gameMode) |
| 72 | » » » { | 77 | » » » { |
| 73 | » » » case·GameModes.Normal: | 78 | » » » case·GameModes.Normal: |
| 74 | » » » case·GameModes.NormalFools: | 79 | » » » case·GameModes.NormalFools: |
| 75 | » » » » this.normalGameHostOptions·=·value·as·NormalGameOptionsV0 | 80 | » » » » this.normalGameHostOptions·=·value·as·NormalGameOptionsV08; |
| 76 | » » » » if·(this.normalGameHostOptions·==·null) | 81 | » » » » if·(this.normalGameHostOptions·==·null) |
| 77 | » » » » { | 82 | » » » » { |
| 78 | » » » » » this.logger.WriteError(string.Format("Setting·host·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(NormalGameOptionsV0 | 83 | » » » » » this.logger.WriteError(string.Format("Setting·host·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(NormalGameOptionsV08))); |
| 79 | » » » » } | 84 | » » » » } |
| 80 | » » » » else | 85 | » » » » else |
| 81 | » » » » { | 86 | » » » » { |
| 82 | » » » » » this.SaveNormalHostOptions(); | 87 | » » » » » this.SaveNormalHostOptions(); |
| 83 | » » » » } | 88 | » » » » } |
| 84 | » » » » break; | 89 | » » » » break; |
| 85 | » » » case·GameModes.HideNSeek: | 90 | » » » case·GameModes.HideNSeek: |
| 86 | » » » case·GameModes.SeekFools: | 91 | » » » case·GameModes.SeekFools: |
| 87 | » » » » this.hideNSeekGameHostOptions·=·value·as·HideNSeekGameOptionsV0 | 92 | » » » » this.hideNSeekGameHostOptions·=·value·as·HideNSeekGameOptionsV08; |
| 88 | » » » » if·(this.hideNSeekGameHostOptions·==·null) | 93 | » » » » if·(this.hideNSeekGameHostOptions·==·null) |
| 89 | » » » » { | 94 | » » » » { |
| 90 | » » » » » this.logger.WriteError(string.Format("Setting·host·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(HideNSeekGameOptionsV0 | 95 | » » » » » this.logger.WriteError(string.Format("Setting·host·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(HideNSeekGameOptionsV08))); |
| 91 | » » » » } | 96 | » » » » } |
| 92 | » » » » else | 97 | » » » » else |
| 93 | » » » » { | 98 | » » » » { |
| 94 | » » » » » this.SaveHideNSeekHostOptions(); | 99 | » » » » » this.SaveHideNSeekHostOptions(); |
| 95 | » » » » } | 100 | » » » » } |
| 96 | » » » » break; | 101 | » » » » break; |
| 97 | » » » default: | 102 | » » » default: |
| Offset 112, 30 lines modified | Offset 117, 30 lines modified | ||
| 112 | » » { | 117 | » » { |
| 113 | » » » GameModes·gameMode·=·value.GameMode; | 118 | » » » GameModes·gameMode·=·value.GameMode; |
| 114 | » » » this.SwitchGameMode(gameMode); | 119 | » » » this.SwitchGameMode(gameMode); |
| 115 | » » » switch·(gameMode) | 120 | » » » switch·(gameMode) |
| 116 | » » » { | 121 | » » » { |
| 117 | » » » case·GameModes.Normal: | 122 | » » » case·GameModes.Normal: |
| 118 | » » » case·GameModes.NormalFools: | 123 | » » » case·GameModes.NormalFools: |
| 119 | » » » » this.normalGameSearchOptions·=·value·as·NormalGameOptionsV0 | 124 | » » » » this.normalGameSearchOptions·=·value·as·NormalGameOptionsV08; |
| 120 | » » » » if·(this.normalGameSearchOptions·==·null) | 125 | » » » » if·(this.normalGameSearchOptions·==·null) |
| 121 | » » » » { | 126 | » » » » { |
| 122 | » » » » » this.logger.WriteError(string.Format("Setting·search·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(NormalGameOptionsV0 | 127 | » » » » » this.logger.WriteError(string.Format("Setting·search·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(NormalGameOptionsV08))); |
| 123 | » » » » } | 128 | » » » » } |
| 124 | » » » » else | 129 | » » » » else |
| 125 | » » » » { | 130 | » » » » { |
| 126 | » » » » » this.SaveNormalSearchOptions(); | 131 | » » » » » this.SaveNormalSearchOptions(); |
| 127 | » » » » } | 132 | » » » » } |
| 128 | » » » » break; | 133 | » » » » break; |
| 129 | » » » case·GameModes.HideNSeek: | 134 | » » » case·GameModes.HideNSeek: |
| 130 | » » » case·GameModes.SeekFools: | 135 | » » » case·GameModes.SeekFools: |
| 131 | » » » » this.hideNSeekGameSearchOptions·=·value·as·HideNSeekGameOptionsV0 | 136 | » » » » this.hideNSeekGameSearchOptions·=·value·as·HideNSeekGameOptionsV08; |
| 132 | » » » » if·(this.hideNSeekGameSearchOptions·==·null) | 137 | » » » » if·(this.hideNSeekGameSearchOptions·==·null) |
| 133 | » » » » { | 138 | » » » » { |
| 134 | » » » » » this.logger.WriteError(string.Format("Setting·search·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(HideNSeekGameOptionsV0 | 139 | » » » » » this.logger.WriteError(string.Format("Setting·search·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(HideNSeekGameOptionsV08))); |
| 135 | » » » » } | 140 | » » » » } |
| 136 | » » » » else | 141 | » » » » else |
| 137 | » » » » { | 142 | » » » » { |
| 138 | » » » » » this.SaveHideNSeekSearchOptions(); | 143 | » » » » » this.SaveHideNSeekSearchOptions(); |
| 139 | » » » » } | 144 | » » » » } |
| 140 | » » » » break; | 145 | » » » » break; |
| 141 | » » » default: | 146 | » » » default: |
| Offset 151, 19 lines modified | Offset 156, 25 lines modified | ||
| 151 | » » if·(GameOptionsManager.Instance·!=·null) | 156 | » » if·(GameOptionsManager.Instance·!=·null) |
| 152 | » » { | 157 | » » { |
| 153 | » » » throw·new·Exception("CANNOT·HAVE·MORE·THAN·ONE·OPTIONS·MANAGER·INSTANCE!"); | 158 | » » » throw·new·Exception("CANNOT·HAVE·MORE·THAN·ONE·OPTIONS·MANAGER·INSTANCE!"); |
| 154 | » » } | 159 | » » } |
| 155 | » » GameOptionsManager.Instance·=·this; | 160 | » » GameOptionsManager.Instance·=·this; |
| 156 | » » this.gameOptionsFactory·=·new·GameOptionsFactory(logger); | 161 | » » this.gameOptionsFactory·=·new·GameOptionsFactory(logger); |
| 157 | » » this.logger·=·logger; | 162 | » » this.logger·=·logger; |
| 158 | » » this.optionsMigrators·=·new·Dictionary<int,·IGameOptionsMigrator> | 163 | » » this.optionsMigrators·=·new·Dictionary<int,·IGameOptionsMigrator> |
| 159 | » » { | 164 | » » { |
| 165 | » » » { | ||
| 160 | » » » 6, | 166 | » » » » 6, |
| 161 | » » » new·GameOptionsMigratorV06toV07(logger) | 167 | » » » » new·GameOptionsMigratorV06toV07(logger) |
| 168 | » » » }, | ||
| 169 | » » » { | ||
| 170 | » » » » 7, | ||
| 171 | » » » » new·GameOptionsMigratorV07toV08(logger) | ||
| 172 | » » » } | ||
| 162 | » » } | 173 | » » }; |
| Max diff block lines reached; 10363/15951 bytes (64.97%) of diff not shown. | |||
| Offset 1, 221 lines modified | Offset 1, 297 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections.Generic; | ||
| 2 | using·AmongUs.GameOptions; | 3 | using·AmongUs.GameOptions; |
| 3 | using·UnityEngine; | 4 | using·UnityEngine; |
| 4 | 5 | ||
| 5 | public·class·GameOptionsMenu·:·MonoBehaviour | 6 | public·class·GameOptionsMenu·:·MonoBehaviour |
| 6 | { | 7 | { |
| 7 | » private·void· | 8 | » private·void·Awake() |
| 8 | » { | 9 | » { |
| 9 | » » this.Children·=·base.GetComponentsInChildren<OptionBehaviour>(); | ||
| 10 | » » this.cachedData·=·GameOptionsManager.Instance.CurrentGameOptions; | ||
| 11 | » » | 10 | » » this.MaskBg.material.SetInt(PlayerMaterial.MaskLayer,·20); |
| 11 | » » this.MaskArea.material.SetInt(PlayerMaterial.MaskLayer,·20); | ||
| 12 | » } | ||
| 13 | |||
| 14 | » private·void·CreateSettings() | ||
| 15 | » { | ||
| 16 | » » float·num·=·0.713f; | ||
| 17 | » » foreach·(RulesCategory·rulesCategory·in·GameManager.Instance.GameSettingsList.AllCategories) | ||
| 12 | » » { | 18 | » » { |
| 13 | » » » OptionBehaviour·optionBehaviour·=·this.Children[i]; | ||
| 14 | » » » optionBehaviour.OnValueChanged·=·new·Action<OptionBehaviour>(this.ValueChanged); | ||
| 15 | » » » | 19 | » » » CategoryHeaderMasked·categoryHeaderMasked·=·Object.Instantiate<CategoryHeaderMasked>(this.categoryHeaderOrigin,·Vector3.zero,·Quaternion.identity,·this.settingsContainer); |
| 20 | » » » categoryHeaderMasked.SetHeader(rulesCategory.CategoryName,·20); | ||
| 21 | » » » categoryHeaderMasked.transform.localScale·=·Vector3.one·*·0.63f; | ||
| 22 | » » » categoryHeaderMasked.transform.localPosition·=·new·Vector3(-0.903f,·num,·-2f); | ||
| 23 | » » » num·-=·0.63f; | ||
| 24 | » » » foreach·(BaseGameSetting·baseGameSetting·in·rulesCategory.AllGameSettings) | ||
| 16 | » » » { | 25 | » » » { |
| 17 | » » » » | 26 | » » » » switch·(baseGameSetting.Type) |
| 27 | » » » » { | ||
| 28 | » » » » case·OptionTypes.Checkbox: | ||
| 29 | » » » » { | ||
| 30 | » » » » » OptionBehaviour·optionBehaviour·=·Object.Instantiate<ToggleOption>(this.checkboxOrigin,·Vector3.zero,·Quaternion.identity,·this.settingsContainer); | ||
| 31 | » » » » » optionBehaviour.transform.localPosition·=·new·Vector3(0.952f,·num,·-2f); | ||
| 32 | » » » » » optionBehaviour.SetClickMask(this.ButtonClickMask); | ||
| 33 | » » » » » optionBehaviour.SetUpFromData(baseGameSetting,·20); | ||
| 34 | » » » » » this.Children.Add(optionBehaviour); | ||
| 35 | » » » » » break; | ||
| 36 | » » » » } | ||
| 37 | » » » » case·OptionTypes.String: | ||
| 38 | » » » » { | ||
| 39 | » » » » » OptionBehaviour·optionBehaviour·=·Object.Instantiate<StringOption>(this.stringOptionOrigin,·Vector3.zero,·Quaternion.identity,·this.settingsContainer); | ||
| 40 | » » » » » optionBehaviour.transform.localPosition·=·new·Vector3(0.952f,·num,·-2f); | ||
| 41 | » » » » » optionBehaviour.SetClickMask(this.ButtonClickMask); | ||
| 42 | » » » » » optionBehaviour.SetUpFromData(baseGameSetting,·20); | ||
| 43 | » » » » » this.Children.Add(optionBehaviour); | ||
| 44 | » » » » » break; | ||
| 45 | » » » » } | ||
| 46 | » » » » case·OptionTypes.Float: | ||
| 47 | » » » » case·OptionTypes.Int: | ||
| 48 | » » » » { | ||
| 49 | » » » » » OptionBehaviour·optionBehaviour·=·Object.Instantiate<NumberOption>(this.numberOptionOrigin,·Vector3.zero,·Quaternion.identity,·this.settingsContainer); | ||
| 50 | » » » » » optionBehaviour.transform.localPosition·=·new·Vector3(0.952f,·num,·-2f); | ||
| 51 | » » » » » optionBehaviour.SetClickMask(this.ButtonClickMask); | ||
| 52 | » » » » » optionBehaviour.SetUpFromData(baseGameSetting,·20); | ||
| 53 | » » » » » this.Children.Add(optionBehaviour); | ||
| 54 | » » » » » break; | ||
| 55 | » » » » } | ||
| 56 | » » » » case·OptionTypes.Player: | ||
| 57 | » » » » { | ||
| 58 | » » » » » OptionBehaviour·optionBehaviour·=·Object.Instantiate<PlayerOption>(this.playerOptionOrigin,·Vector3.zero,·Quaternion.identity,·this.settingsContainer); | ||
| 59 | » » » » » optionBehaviour.transform.localPosition·=·new·Vector3(0.952f,·num,·-2f); | ||
| 60 | » » » » » optionBehaviour.SetClickMask(this.ButtonClickMask); | ||
| 61 | » » » » » optionBehaviour.SetUpFromData(baseGameSetting,·20); | ||
| 62 | » » » » » this.Children.Add(optionBehaviour); | ||
| 63 | » » » » » break; | ||
| 64 | » » » » } | ||
| 65 | » » » » } | ||
| 66 | » » » » num·-=·0.45f; | ||
| 18 | » » » } | 67 | » » » } |
| 19 | » » } | 68 | » » } |
| 69 | » » this.ControllerSelectable.AddRange(this.scrollBar.GetComponentsInChildren<UiElement>()); | ||
| 70 | » » this.scrollBar.SetYBoundsMax(-num·-·1.65f); | ||
| 71 | » } | ||
| 72 | |||
| 73 | » private·void·Initialize() | ||
| 74 | » { | ||
| 75 | » » if·(this.Children·==·null·||·this.Children.Count·==·0) | ||
| 76 | » » { | ||
| 77 | » » » this.MapPicker.Initialize(20); | ||
| 78 | » » » BaseGameSetting·mapNameSetting·=·GameManager.Instance.GameSettingsList.MapNameSetting; | ||
| 79 | » » » this.MapPicker.SetUpFromData(mapNameSetting,·20); | ||
| 80 | » » » this.Children·=·new·List<OptionBehaviour>(); | ||
| 81 | » » » this.Children.Add(this.MapPicker); | ||
| 82 | » » » this.CreateSettings(); | ||
| 83 | » » » this.cachedData·=·GameOptionsManager.Instance.CurrentGameOptions; | ||
| 84 | » » » for·(int·i·=·0;·i·<·this.Children.Count;·i++) | ||
| 85 | » » » { | ||
| 86 | » » » » OptionBehaviour·optionBehaviour·=·this.Children[i]; | ||
| 87 | » » » » optionBehaviour.OnValueChanged·=·new·Action<OptionBehaviour>(this.ValueChanged); | ||
| 88 | » » » » if·(AmongUsClient.Instance·&&·!AmongUsClient.Instance.AmHost) | ||
| 89 | » » » » { | ||
| 90 | » » » » » optionBehaviour.SetAsPlayer(); | ||
| 91 | » » » » } | ||
| 92 | » » » } | ||
| 93 | » » » this.InitializeControllerNavigation(); | ||
| 94 | » » } | ||
| 20 | » } | 95 | » } |
| 21 | 96 | ||
| 22 | » private·void·Update() | 97 | » private·void·Update() |
| 23 | » { | 98 | » { |
| 24 | » » if·(this.cachedData·!=·GameOptionsManager.Instance.CurrentGameOptions) | 99 | » » if·(this.cachedData·!=·GameOptionsManager.Instance.CurrentGameOptions) |
| 25 | » » { | 100 | » » { |
| 26 | » » » this.cachedData·=·GameOptionsManager.Instance.CurrentGameOptions; | 101 | » » » this.cachedData·=·GameOptionsManager.Instance.CurrentGameOptions; |
| 27 | » » » this.RefreshChildren(); | 102 | » » » this.RefreshChildren(); |
| 28 | » » } | 103 | » » } |
| 29 | » } | 104 | » } |
| 30 | 105 | ||
| 106 | » private·void·OnEnable() | ||
| 107 | » { | ||
| 108 | » » this.Initialize(); | ||
| 109 | » } | ||
| 110 | |||
| 111 | » private·void·OnDisable() | ||
| 112 | » { | ||
| 113 | » » this.CloseMenu(); | ||
| 114 | » } | ||
| 115 | |||
| 116 | » public·void·OpenMenu() | ||
| 117 | » { | ||
| 118 | » » ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton,·this.MapPicker.MapButtons[0].Button,·this.ControllerSelectable,·false); | ||
| 119 | » } | ||
| 120 | |||
| 121 | » public·void·CloseMenu() | ||
| 122 | » { | ||
| 123 | » » ControllerManager.Instance.CloseOverlayMenu(base.name); | ||
| Max diff block lines reached; 11955/17064 bytes (70.06%) of diff not shown. | |||
| Offset 1, 242 lines modified | Offset 1, 197 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections; | ||
| 2 | using·System.Collections.Generic; | 3 | using·System.Collections.Generic; |
| 3 | using·AmongUs.GameOptions; | ||
| 4 | using·Rewired; | ||
| 5 | using·TMPro; | 4 | using·TMPro; |
| 6 | using·UnityEngine; | 5 | using·UnityEngine; |
| 7 | 6 | ||
| 8 | public·class·GameSettingMenu·:·MonoBehaviour | 7 | public·class·GameSettingMenu·:·MonoBehaviour |
| 9 | { | 8 | { |
| 10 | » public·void·Close() | 9 | » public·void·Close() |
| 11 | » { | 10 | » { |
| 12 | » » GameSettingMenu.Instance·=·null; | 11 | » » GameSettingMenu.Instance·=·null; |
| 13 | » » Object.Destroy(base.gameObject); | 12 | » » Object.Destroy(base.gameObject); |
| 14 | » } | 13 | » } |
| 15 | 14 | ||
| 16 | » public·void·ToggleRoles() | ||
| 17 | » { | ||
| 18 | » » bool·activeSelf·=·this.RegularGameSettings.activeSelf; | ||
| 19 | » » this.RegularGameSettings.SetActive(!activeSelf); | ||
| 20 | » » this.RolesSettings.gameObject.SetActive(activeSelf); | ||
| 21 | » » this.GameSettingsHightlight.enabled·=·!activeSelf; | ||
| 22 | » » this.RolesSettingsHightlight.enabled·=·activeSelf; | ||
| 23 | » } | ||
| 24 | |||
| 25 | » private·void·Start() | 15 | » private·void·Start() |
| 26 | » { | 16 | » { |
| 27 | » » if·(GameSettingMenu.Instance·&&·GameSettingMenu.Instance·!=·this) | 17 | » » if·(GameSettingMenu.Instance·&&·GameSettingMenu.Instance·!=·this) |
| 28 | » » { | 18 | » » { |
| 29 | » » » Object.Destroy(base.gameObject); | 19 | » » » Object.Destroy(base.gameObject); |
| 30 | » » } | 20 | » » } |
| 31 | » » else | 21 | » » else |
| 32 | » » { | 22 | » » { |
| 33 | » » » GameSettingMenu.Instance·=·this; | 23 | » » » GameSettingMenu.Instance·=·this; |
| 34 | » » } | 24 | » » } |
| 25 | » » this.GamePresetsButton.OnClick.AddListener(delegate | ||
| 35 | » » DestroyableSingleton<HudManager>.Instance.menuNavigationPrompts.SetActive(false); | ||
| 36 | » » this.ShowSettingsByGameType(); | ||
| 37 | » } | ||
| 38 | |||
| 39 | » private·void·ShowSettingsByGameType() | ||
| 40 | » { | ||
| 41 | » » if·(GameOptionsManager.Instance.CurrentGameOptions.GameMode·==·GameModes.HideNSeek) | ||
| 42 | » » { | 26 | » » { |
| 43 | » » » this.InitializeHideAndSeekOptions(); | ||
| 44 | » » » this. | 27 | » » » this.ChangeTab(0,·false); |
| 28 | » » }); | ||
| 29 | » » this.GamePresetsButton.OnMouseOver.AddListener(delegate | ||
| 30 | » » { | ||
| 31 | » » » this.ChangeTab(0,·true); | ||
| 32 | » » }); | ||
| 33 | » » this.GameSettingsButton.OnClick.AddListener(delegate | ||
| 34 | » » { | ||
| 35 | » » » this.ChangeTab(1,·false); | ||
| 36 | » » }); | ||
| 37 | » » this.GameSettingsButton.OnMouseOver.AddListener(delegate | ||
| 38 | » » { | ||
| 39 | » » » this.ChangeTab(1,·true); | ||
| 40 | » » }); | ||
| 41 | » » this.RoleSettingsButton.OnClick.AddListener(delegate | ||
| 42 | » » { | ||
| 43 | » » » this.ChangeTab(2,·false); | ||
| 44 | » » }); | ||
| 45 | » » this.RoleSettingsButton.OnMouseOver.AddListener(delegate | ||
| 46 | » » { | ||
| 47 | » » » this.ChangeTab(2,·true); | ||
| 48 | » » }); | ||
| 49 | » » if·(GameManager.Instance.IsHideAndSeek()) | ||
| 50 | » » { | ||
| 45 | » » » this.Role | 51 | » » » this.RoleSettingsButton.gameObject.SetActive(false); |
| 46 | » » » this.RegularGameSettings.SetActive(false); | ||
| 47 | » » » this.Tabs.SetActive(false); | ||
| 48 | » » » ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton,·this.DefaultButtonSelected[1],·this.ControllerSelectableHidenSeek,·false); | ||
| 49 | » » » return; | ||
| 50 | » » } | 52 | » » } |
| 51 | » » this.InitializeNormalOptions(); | ||
| 52 | » » this.RolesSettings.gameObject.SetActive(false); | ||
| 53 | » » this.RegularGameSettings.SetActive(true); | ||
| 54 | » » this.HideNSeekSettings.SetActive(false); | ||
| 55 | » » this.Tabs.SetActive(true); | ||
| 56 | » » ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton,·this.DefaultButtonSelected[0],·this.ControllerSelectable,·false); | ||
| 57 | » } | 53 | » } |
| 58 | 54 | ||
| 59 | » private·void·Update() | 55 | » private·void·Update() |
| 60 | » { | 56 | » { |
| 61 | » » if·(ShipStatus.Instance) | 57 | » » if·(ShipStatus.Instance) |
| 62 | » » { | 58 | » » { |
| 63 | » » » this.Close(); | 59 | » » » this.Close(); |
| 64 | » » » return; | 60 | » » » return; |
| 65 | » » } | 61 | » » } |
| 62 | » » if·(Controller.currentTouchType·!=·Controller.TouchType.Joystick) | ||
| 66 | » » Player·player·=·ReInput.players.GetPlayer(0); | ||
| 67 | » » if·(GameOptionsManager.Instance.CurrentGameOptions.GameMode·==·GameModes.Normal·&&·(player.GetButtonDown(35)·||·player.GetButtonDown(34))) | ||
| 68 | » » { | 63 | » » { |
| 69 | » » » this.Toggle | 64 | » » » this.ToggleLeftSideDarkener(false); |
| 65 | » » » this.ToggleRightSideDarkener(false); | ||
| 70 | » » } | 66 | » » } |
| 71 | » } | 67 | » } |
| 72 | 68 | ||
| 73 | » private·void·OnEnable() | 69 | » private·void·OnEnable() |
| 74 | » { | 70 | » { |
| 75 | » » this. | 71 | » » ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton,·this.DefaultButtonSelected,·this.ControllerSelectable,·false); |
| 72 | » » DestroyableSingleton<HudManager>.Instance.menuNavigationPrompts.SetActive(false); | ||
| 73 | » » if·(Controller.currentTouchType·!=·Controller.TouchType.Joystick) | ||
| 74 | » » { | ||
| 75 | » » » this.ChangeTab(0,·Controller.currentTouchType·==·Controller.TouchType.Joystick); | ||
| 76 | » » } | ||
| 77 | » » base.StartCoroutine(this.CoSelectDefault()); | ||
| 76 | » } | 78 | » } |
| 77 | 79 | ||
| 78 | » private·void·OnDisable() | 80 | » private·void·OnDisable() |
| 79 | » { | 81 | » { |
| 80 | » » DestroyableSingleton<HudManager>.Instance.menuNavigationPrompts.SetActive(true); | 82 | » » DestroyableSingleton<HudManager>.Instance.menuNavigationPrompts.SetActive(true); |
| 81 | » » ControllerManager.Instance.CloseOverlayMenu(base.name); | 83 | » » ControllerManager.Instance.CloseOverlayMenu(base.name); |
| 82 | » } | 84 | » } |
| 83 | 85 | ||
| 86 | » private·IEnumerator·CoSelectDefault() | ||
| 84 | » private·void·InitializeHideAndSeekOptions() | ||
| 85 | » { | ||
| 86 | » » this.InitializeOptions(this.AllHideAndSeekItems,·this.HideAndSeekScroller); | ||
| 87 | » } | ||
| 88 | |||
| 89 | » private·void·InitializeNormalOptions() | ||
| 90 | » { | 87 | » { |
| 91 | » » | 88 | » » yield·return·new·WaitForEndOfFrame(); |
| 89 | » » ControllerManager.Instance.SetCurrentSelected(this.DefaultButtonSelected); | ||
| 90 | » » yield·break; | ||
| Max diff block lines reached; 7078/11321 bytes (62.52%) of diff not shown. | |||
| Offset 1, 101 lines modified | Offset 1, 237 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections; | 2 | using·System.Collections.Generic; |
| 3 | using·AmongUs.Data; | 3 | using·AmongUs.Data; |
| 4 | using·AmongUs.GameOptions; | ||
| 4 | using·InnerNet; | 5 | using·InnerNet; |
| 5 | using·TMPro; | 6 | using·TMPro; |
| 6 | using·UnityEngine; | 7 | using·UnityEngine; |
| 7 | 8 | ||
| 8 | public·class·GameStartManager·:·DestroyableSingleton<GameStartManager>,·IDisconnectHandler | 9 | public·class·GameStartManager·:·DestroyableSingleton<GameStartManager>,·IDisconnectHandler |
| 9 | { | 10 | { |
| 11 | » public·bool·IsPersistent | ||
| 12 | » { | ||
| 13 | » » get | ||
| 14 | » » { | ||
| 15 | » » » return·false; | ||
| 16 | » » } | ||
| 17 | » } | ||
| 18 | |||
| 10 | » public·void·Start() | 19 | » public·void·Start() |
| 11 | » { | 20 | » { |
| 12 | » » if·(DestroyableSingleton<TutorialManager>.InstanceExists) | 21 | » » if·(DestroyableSingleton<TutorialManager>.InstanceExists) |
| 13 | » » { | 22 | » » { |
| 14 | » » » Object.Destroy(base.gameObject); | 23 | » » » Object.Destroy(base.gameObject); |
| 15 | » » » return; | 24 | » » » return; |
| 16 | » » } | 25 | » » } |
| 26 | » » this.LobbyInfoPane.gameObject.SetActive(true); | ||
| 17 | » » DataManager.Settings.Gameplay.OnStreamerModeChanged·+=·this.UpdateStreamerModeUI; | 27 | » » DataManager.Settings.Gameplay.OnStreamerModeChanged·+=·this.UpdateStreamerModeUI; |
| 18 | » » this.UpdateStreamerModeUI(); | 28 | » » this.UpdateStreamerModeUI(); |
| 19 | » » if·(GameCode.IntToGameName(AmongUsClient.Instance.GameId)· | 29 | » » if·(GameCode.IntToGameName(AmongUsClient.Instance.GameId)·==·null) |
| 20 | » » { | 30 | » » { |
| 31 | » » » this.RoomCodeHeader.gameObject.SetActive(false); | ||
| 21 | » » » this.GameRoomNameInfo.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoomCodeInfo,·Array.Empty<object>()); | ||
| 22 | » » } | ||
| 23 | » » else | ||
| 24 | » » { | ||
| 25 | » » » this.StartButton.transform.localPosition·=·new·Vector3(0f,·-0.2f,·0f); | ||
| 26 | » » » this.PlayerCounter.transform.localPosition·=·new·Vector3(0f,·-0.8f,·0f); | ||
| 27 | » » » this.GameRoomButton.gameObject.SetActive(false); | 32 | » » » this.GameRoomButton.gameObject.SetActive(false); |
| 33 | » » » this.LocalLabel.gameObject.SetActive(true); | ||
| 34 | » » » this.HostPrivacyButtons.gameObject.SetActive(false); | ||
| 35 | » » » this.ClientPrivacyValue.gameObject.SetActive(true); | ||
| 28 | » » } | 36 | » » } |
| 29 | » » AmongUsClient.Instance.DisconnectHandlers.AddUnique(this); | 37 | » » AmongUsClient.Instance.DisconnectHandlers.AddUnique(this); |
| 38 | » » this.DoHostSetup(); | ||
| 39 | » » if·(AmongUsClient.Instance.AmHost) | ||
| 40 | » » { | ||
| 41 | » » » LobbyBehaviour.Instance·=·Object.Instantiate<LobbyBehaviour>(this.LobbyPrefab); | ||
| 42 | » » » AmongUsClient.Instance.Spawn(LobbyBehaviour.Instance,·-2,·SpawnFlags.None); | ||
| 43 | » » } | ||
| 44 | » » this.ShareOnDiscordButton.gameObject.SetActive(false); | ||
| 45 | » } | ||
| 46 | |||
| 47 | » private·void·DoHostSetup() | ||
| 48 | » { | ||
| 49 | » » string·text·=·GameCode.IntToGameName(AmongUsClient.Instance.GameId); | ||
| 30 | » » if·(!AmongUsClient.Instance.AmHost) | 50 | » » if·(!AmongUsClient.Instance.AmHost) |
| 31 | » » { | 51 | » » { |
| 52 | » » » this.HostPrivacyButtons.gameObject.SetActive(false); | ||
| 53 | » » » this.ClientPrivacyValue.gameObject.SetActive(true); | ||
| 32 | » » » this.StartButton.gameObject.SetActive(false); | 54 | » » » this.StartButton.gameObject.SetActive(false); |
| 55 | » » » this.StartButtonClient.gameObject.SetActive(true); | ||
| 56 | » » » this.GameStartTextParent.SetActive(false); | ||
| 57 | » » » this.HostInfoPanelButtons.gameObject.SetActive(false); | ||
| 58 | » » » this.ClientInfoPanelButtons.gameObject.SetActive(true); | ||
| 59 | » » » return; | ||
| 33 | » » » this.MakePublicButtonBehaviour.enabled·=·false; | ||
| 34 | » » » ActionMapGlyphDisplay·componentInChildren·=·this.MakePublicButton.GetComponentInChildren<ActionMapGlyphDisplay>(true); | ||
| 35 | » » » if·(componentInChildren) | ||
| 36 | » » » { | ||
| 37 | » » » » componentInChildren.gameObject.SetActive(false); | ||
| 38 | » » » } | ||
| 39 | » » } | 60 | » » } |
| 40 | » » el | 61 | » » if·(text·!=·null) |
| 41 | » » { | 62 | » » { |
| 42 | » » » LobbyBehaviour.Instance·=·Object.Instantiate<LobbyBehaviour>(this.LobbyPrefab); | ||
| 43 | » » » | 63 | » » » this.HostPrivacyButtons.gameObject.SetActive(true); |
| 64 | » » » this.ClientPrivacyValue.gameObject.SetActive(false); | ||
| 44 | » » } | 65 | » » } |
| 45 | » » this. | 66 | » » this.HostInfoPanelButtons.gameObject.SetActive(true); |
| 67 | » » this.ClientInfoPanelButtons.gameObject.SetActive(false); | ||
| 68 | » » this.StartButton.gameObject.SetActive(true); | ||
| 46 | » » this.S | 69 | » » this.StartButtonClient.gameObject.SetActive(false); |
| 47 | » } | 70 | » } |
| 48 | 71 | ||
| 49 | » public·override·void·OnDestroy() | 72 | » public·override·void·OnDestroy() |
| 50 | » { | 73 | » { |
| 51 | » » base.OnDestroy(); | 74 | » » base.OnDestroy(); |
| 52 | » » DataManager.Settings.Gameplay.OnStreamerModeChanged·-=·this.UpdateStreamerModeUI; | 75 | » » DataManager.Settings.Gameplay.OnStreamerModeChanged·-=·this.UpdateStreamerModeUI; |
| 53 | » } | 76 | » } |
| 54 | 77 | ||
| 78 | » public·void·ClickEdit() | ||
| 79 | » { | ||
| 80 | » » PlayerControl·localPlayer·=·PlayerControl.LocalPlayer; | ||
| 81 | » » if·(AmongUsClient.Instance.AmHost) | ||
| 82 | » » { | ||
| 83 | » » » localPlayer.NetTransform.Halt(); | ||
| 84 | » » » GameObject·gameObject·=·Object.Instantiate<GameObject>(this.PlayerOptionsMenu); | ||
| 85 | » » » gameObject.transform.SetParent(Camera.main.transform,·false); | ||
| 86 | » » » gameObject.transform.localPosition·=·this.GameOptionsPosition; | ||
| 87 | » » » DestroyableSingleton<TransitionFade>.Instance.DoTransitionFade(null,·gameObject.gameObject,·null); | ||
| 88 | » » » this.RulesViewPanel.SetActive(false); | ||
| 89 | » » » this.SelectViewButton(false); | ||
| 90 | » » » this.LobbyInfoPane.DeactivatePane(); | ||
| 91 | » » } | ||
| 92 | » } | ||
| 93 | |||
| 55 | » private·void·UpdateStreamerModeUI() | 94 | » private·void·UpdateStreamerModeUI() |
| 56 | » { | 95 | » { |
| 57 | » » string·text·=·GameCode.IntToGameName(AmongUsClient.Instance.GameId); | 96 | » » string·text·=·GameCode.IntToGameName(AmongUsClient.Instance.GameId); |
| 58 | » » if·(text·==·null) | 97 | » » if·(text·==·null) |
| 59 | » » { | 98 | » » { |
| 60 | » » » text·=· | 99 | » » » text·=·string.Empty; |
| 61 | » » } | 100 | » » } |
| 62 | » » this.GameRoomNameCode.text·=·(DataManager.Settings.Gameplay.StreamerMode·?·"******"·:·text); | 101 | » » this.GameRoomNameCode.text·=·((DataManager.Settings.Gameplay.StreamerMode·&&·text·!=·string.Empty)·?·"******"·:·text); |
| 63 | » } | 102 | » } |
| 64 | 103 | ||
| 65 | » public·void·MakePublic() | 104 | » public·void·MakePublic() |
| 66 | » { | 105 | » { |
| 67 | » » if·(AmongUsClient.Instance.AmHost) | 106 | » » if·(AmongUsClient.Instance.AmHost) |
| 68 | » » { | 107 | » » { |
| 69 | » » » AmongUsClient.Instance.ChangeGamePublic(!AmongUsClient.Instance.IsGamePublic); | 108 | » » » AmongUsClient.Instance.ChangeGamePublic(!AmongUsClient.Instance.IsGamePublic); |
| 70 | » » » this. | 109 | » » » this.HostPrivateButton.gameObject.SetActive(!AmongUsClient.Instance.IsGamePublic); |
| 110 | » » » this.HostPublicButton.gameObject.SetActive(AmongUsClient.Instance.IsGamePublic); | ||
| 111 | » » » if·(ActiveInputManager.currentControlType·==·ActiveInputManager.InputType.Joystick) | ||
| 112 | » » » { | ||
| 113 | » » » » if·(AmongUsClient.Instance.IsGamePublic) | ||
| 114 | » » » » { | ||
| Max diff block lines reached; 17081/22484 bytes (75.97%) of diff not shown. | |||
| Offset 21, 18 lines modified | Offset 21, 19 lines modified | ||
| 21 | » } | 21 | » } |
| 22 | 22 | ||
| 23 | » public·void·StartDownOutroAnimation() | 23 | » public·void·StartDownOutroAnimation() |
| 24 | » { | 24 | » { |
| 25 | » » base.StartCoroutine(this.CoDownOutroAnimation()); | 25 | » » base.StartCoroutine(this.CoDownOutroAnimation()); |
| 26 | » } | 26 | » } |
| 27 | 27 | ||
| 28 | » public·void·SetPlayerColor( | 28 | » public·void·SetPlayerColor(NetworkedPlayerInfo.PlayerOutfit·outfit,·PlayerMaterial.MaskType·maskType,·float·alpha) |
| 29 | » { | 29 | » { |
| 30 | » » this.handRenderer.sharedMaterial·=·CosmeticsLayer.GetBodyMaterial(maskType); | 30 | » » this.handRenderer.sharedMaterial·=·CosmeticsLayer.GetBodyMaterial(maskType); |
| 31 | » » PlayerMaterial.SetColors(outfit.ColorId,·this.handRenderer); | 31 | » » PlayerMaterial.SetColors(outfit.ColorId,·this.handRenderer); |
| 32 | » » this.handRenderer.color·=·this.handRenderer.color.SetAlpha(alpha); | ||
| 32 | » } | 33 | » } |
| 33 | 34 | ||
| 34 | » private·IEnumerator·CoDownAnimation() | 35 | » private·IEnumerator·CoDownAnimation() |
| 35 | » { | 36 | » { |
| 36 | » » this.spriteAnim.Play(this.DownIntroAnim,·1f); | 37 | » » this.spriteAnim.Play(this.DownIntroAnim,·1f); |
| 37 | » » yield·return·new·WaitForAnimationFinish(this.spriteAnim,·this.DownIntroAnim,·true,·-1); | 38 | » » yield·return·new·WaitForAnimationFinish(this.spriteAnim,·this.DownIntroAnim,·true,·-1); |
| 38 | » » this.spriteAnim.Play(this.DownLoopAnim,·1f); | 39 | » » this.spriteAnim.Play(this.DownLoopAnim,·1f); |
| Offset 59, 14 lines modified | Offset 60, 23 lines modified | ||
| 59 | » { | 60 | » { |
| 60 | » » this.spriteAnim.Play(this.UpOutroAnim,·1f); | 61 | » » this.spriteAnim.Play(this.UpOutroAnim,·1f); |
| 61 | » » yield·return·new·WaitForAnimationFinish(this.spriteAnim,·this.UpOutroAnim,·true,·-1); | 62 | » » yield·return·new·WaitForAnimationFinish(this.spriteAnim,·this.UpOutroAnim,·true,·-1); |
| 62 | » » base.gameObject.SetActive(false); | 63 | » » base.gameObject.SetActive(false); |
| 63 | » » yield·break; | 64 | » » yield·break; |
| 64 | » } | 65 | » } |
| 65 | 66 | ||
| 67 | » public·void·Hide() | ||
| 68 | » { | ||
| 69 | » » SpriteRenderer[]·componentsInChildren·=·base.GetComponentsInChildren<SpriteRenderer>(); | ||
| 70 | » » for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++) | ||
| 71 | » » { | ||
| 72 | » » » componentsInChildren[i].color·=·Color.clear; | ||
| 73 | » » } | ||
| 74 | » } | ||
| 75 | |||
| 66 | » [SerializeField] | 76 | » [SerializeField] |
| 67 | » private·SpriteRenderer·handRenderer; | 77 | » private·SpriteRenderer·handRenderer; |
| 68 | 78 | ||
| 69 | » [SerializeField] | 79 | » [SerializeField] |
| 70 | » private·SpriteAnim·spriteAnim; | 80 | » private·SpriteAnim·spriteAnim; |
| 71 | 81 | ||
| 72 | » [SerializeField] | 82 | » [SerializeField] |
| Offset 239, 15 lines modified | Offset 239, 15 lines modified | ||
| 239 | » » } | 239 | » » } |
| 240 | » » return·true; | 240 | » » return·true; |
| 241 | » } | 241 | » } |
| 242 | 242 | ||
| 243 | » private·T[]·GetSorted<T>(List<T>·all)·where·T·:·CosmeticData | 243 | » private·T[]·GetSorted<T>(List<T>·all)·where·T·:·CosmeticData |
| 244 | » { | 244 | » { |
| 245 | » » CosmeticGroups·groups·=·DestroyableSingleton<ReferenceDataManager>.Instance.Refdata.Groups; | 245 | » » CosmeticGroups·groups·=·DestroyableSingleton<ReferenceDataManager>.Instance.Refdata.Groups; |
| 246 | » » T[]·array·=·Enumerable.ToArray<T>(Enumerable.ThenBy<T,· | 246 | » » T[]·array·=·Enumerable.ToArray<T>(Enumerable.ThenBy<T,·int>(Enumerable.ThenByDescending<T,·DateTime>(Enumerable.OrderBy<T,·int>(all,·(T·x)·=>·x.displayOrder),·(T·x)·=>·groups.GetReleaseGroupDate(x)),·(T·x)·=>·groups.GetReleaseGroupIndex(x))); |
| 247 | » » List<T>·list·=·new·List<T>(); | 247 | » » List<T>·list·=·new·List<T>(); |
| 248 | » » foreach·(T·t·in·array) | 248 | » » foreach·(T·t·in·array) |
| 249 | » » { | 249 | » » { |
| 250 | » » » if·(!list.Contains(t)) | 250 | » » » if·(!list.Contains(t)) |
| 251 | » » » { | 251 | » » » { |
| 252 | » » » » if·(this.CheckValidCosmetic(t.ProdId)) | 252 | » » » » if·(this.CheckValidCosmetic(t.ProdId)) |
| 253 | » » » » { | 253 | » » » » { |
| Offset 94, 18 lines modified | Offset 94, 24 lines modified | ||
| 94 | » » if·(!this.Hat) | 94 | » » if·(!this.Hat) |
| 95 | » » { | 95 | » » { |
| 96 | » » » return; | 96 | » » » return; |
| 97 | » » } | 97 | » » } |
| 98 | » » this.SetHat(colorId); | 98 | » » this.SetHat(colorId); |
| 99 | » } | 99 | » } |
| 100 | 100 | ||
| 101 | » public·void·SetShouldFaceLeft(bool·leftFacingVictim) | ||
| 102 | » { | ||
| 103 | » » this.shouldFaceLeft·=·leftFacingVictim; | ||
| 104 | » } | ||
| 105 | |||
| 101 | » public·void·SetFloorAnim() | 106 | » public·void·SetFloorAnim() |
| 102 | » { | 107 | » { |
| 103 | » » this.BackLayer.enabled·=·false; | 108 | » » this.BackLayer.enabled·=·false; |
| 104 | » » this.FrontLayer.enabled·=·true; | 109 | » » this.FrontLayer.enabled·=·true; |
| 110 | » » this.FrontLayer.flipX·=·false; | ||
| 105 | » » this.FrontLayer.sprite·=·this.viewAsset.GetAsset().FloorImage; | 111 | » » this.FrontLayer.sprite·=·this.viewAsset.GetAsset().FloorImage; |
| 106 | » } | 112 | » } |
| 107 | 113 | ||
| 108 | » public·void·SetClimbAnim() | 114 | » public·void·SetClimbAnim() |
| 109 | » { | 115 | » { |
| 110 | » » if·(!this.options.ShowForClimb) | 116 | » » if·(!this.options.ShowForClimb) |
| 111 | » » { | 117 | » » { |
| Offset 277, 24 lines modified | Offset 283, 24 lines modified | ||
| 277 | » » » HatViewData·hatViewData·=·((addressableAsset·!=·null)·?·addressableAsset.GetAsset()·:·null); | 283 | » » » HatViewData·hatViewData·=·((addressableAsset·!=·null)·?·addressableAsset.GetAsset()·:·null); |
| 278 | » » » if·(this.Hat·&&·hatViewData·!=·null) | 284 | » » » if·(this.Hat·&&·hatViewData·!=·null) |
| 279 | » » » { | 285 | » » » { |
| 280 | » » » » if·(this.FrontLayer.sprite·!=·hatViewData.ClimbImage·&&·this.FrontLayer.sprite·!=·hatViewData.FloorImage) | 286 | » » » » if·(this.FrontLayer.sprite·!=·hatViewData.ClimbImage·&&·this.FrontLayer.sprite·!=·hatViewData.FloorImage) |
| 281 | » » » » { | 287 | » » » » { |
| 282 | » » » » » if·((this.Hat.InFront·||·hatViewData.BackImage)·&&·hatViewData.LeftMainImage) | 288 | » » » » » if·((this.Hat.InFront·||·hatViewData.BackImage)·&&·hatViewData.LeftMainImage) |
| 283 | » » » » » { | 289 | » » » » » { |
| 284 | » » » » » » this.FrontLayer.sprite·=·(this.Parent.flipX·?·hatViewData.LeftMainImage·:·hatViewData.MainImage); | 290 | » » » » » » this.FrontLayer.sprite·=·((this.Parent.flipX·||·this.shouldFaceLeft)·?·hatViewData.LeftMainImage·:·hatViewData.MainImage); |
| 285 | » » » » » } | 291 | » » » » » } |
| 286 | » » » » » if·(hatViewData.BackImage·&&·hatViewData.LeftBackImage) | 292 | » » » » » if·(hatViewData.BackImage·&&·hatViewData.LeftBackImage) |
| 287 | » » » » » { | 293 | » » » » » { |
| 288 | » » » » » » this.BackLayer.sprite·=·(this.Parent.flipX·?·hatViewData.LeftBackImage·:·hatViewData.BackImage); | 294 | » » » » » » this.BackLayer.sprite·=·((this.Parent.flipX·||·this.shouldFaceLeft)·?·hatViewData.LeftBackImage·:·hatViewData.BackImage); |
| 289 | » » » » » » return; | 295 | » » » » » » return; |
| 290 | » » » » » } | 296 | » » » » » } |
| 291 | » » » » » if·(!hatViewData.BackImage·&&·!this.Hat.InFront·&&·hatViewData.LeftMainImage) | 297 | » » » » » if·(!hatViewData.BackImage·&&·!this.Hat.InFront·&&·hatViewData.LeftMainImage) |
| 292 | » » » » » { | 298 | » » » » » { |
| 293 | » » » » » » this.BackLayer.sprite·=·(this.Parent.flipX·?·hatViewData.LeftMainImage·:·hatViewData.MainImage); | 299 | » » » » » » this.BackLayer.sprite·=·((this.Parent.flipX·||·this.shouldFaceLeft)·?·hatViewData.LeftMainImage·:·hatViewData.MainImage); |
| 294 | » » » » » » return; | 300 | » » » » » » return; |
| 295 | » » » » » } | 301 | » » » » » } |
| 296 | » » » » } | 302 | » » » » } |
| 297 | » » » » else·if·(this.FrontLayer.sprite·==·hatViewData.ClimbImage·||·this.FrontLayer.sprite·==·hatViewData.LeftClimbImage) | 303 | » » » » else·if·(this.FrontLayer.sprite·==·hatViewData.ClimbImage·||·this.FrontLayer.sprite·==·hatViewData.LeftClimbImage) |
| 298 | » » » » { | 304 | » » » » { |
| 299 | » » » » » SpriteAnimNodeSync·spriteAnimNodeSync·=·this.SpriteSyncNode·??·base.GetComponent<SpriteAnimNodeSync>(); | 305 | » » » » » SpriteAnimNodeSync·spriteAnimNodeSync·=·this.SpriteSyncNode·??·base.GetComponent<SpriteAnimNodeSync>(); |
| 300 | » » » » » if·(spriteAnimNodeSync) | 306 | » » » » » if·(spriteAnimNodeSync) |
| Offset 315, 8 lines modified | Offset 321, 10 lines modified | ||
| 315 | » public·SpriteAnimNodeSync·SpriteSyncNode; | 321 | » public·SpriteAnimNodeSync·SpriteSyncNode; |
| 316 | 322 | ||
| 317 | » private·AddressableAsset<HatViewData>·viewAsset; | 323 | » private·AddressableAsset<HatViewData>·viewAsset; |
| 318 | 324 | ||
| 319 | » private·PlayerMaterial.Properties·matProperties; | 325 | » private·PlayerMaterial.Properties·matProperties; |
| 320 | 326 | ||
| 321 | » private·HatOptions·options; | 327 | » private·HatOptions·options; |
| 328 | |||
| 329 | » private·bool·shouldFaceLeft; | ||
| 322 | } | 330 | } |
| Offset 150, 15 lines modified | Offset 150, 15 lines modified | ||
| 150 | » » » this.FilterText.text·=·""; | 150 | » » » this.FilterText.text·=·""; |
| 151 | » » » this.HauntingText.enabled·=·false; | 151 | » » » this.HauntingText.enabled·=·false; |
| 152 | » » » return; | 152 | » » » return; |
| 153 | » » } | 153 | » » } |
| 154 | » » this.HauntTarget·=·target; | 154 | » » this.HauntTarget·=·target; |
| 155 | » » this.HauntingText.enabled·=·true; | 155 | » » this.HauntingText.enabled·=·true; |
| 156 | » » TMP_Text·nameText·=·this.NameText; | 156 | » » TMP_Text·nameText·=·this.NameText; |
| 157 | » » | 157 | » » NetworkedPlayerInfo·data·=·target.Data; |
| 158 | » » nameText.text·=·((data·!=·null)·?·data.GetPlayerName(PlayerOutfitType.Default)·:·null); | 158 | » » nameText.text·=·((data·!=·null)·?·data.GetPlayerName(PlayerOutfitType.Default)·:·null); |
| 159 | » » this.SetFilterText(); | 159 | » » this.SetFilterText(); |
| 160 | » } | 160 | » } |
| 161 | 161 | ||
| 162 | » public·override·void·Close() | 162 | » public·override·void·Close() |
| 163 | » { | 163 | » { |
| 164 | » » DestroyableSingleton<HudManager>.Instance.ToggleMapButton(true); | 164 | » » DestroyableSingleton<HudManager>.Instance.ToggleMapButton(true); |
| Offset 5, 15 lines modified | Offset 5, 15 lines modified | ||
| 5 | public·class·HideAndSeekDeathPopupNameplate·:·MonoBehaviour | 5 | public·class·HideAndSeekDeathPopupNameplate·:·MonoBehaviour |
| 6 | { | 6 | { |
| 7 | » public·void·SetPlayer(PlayerControl·player) | 7 | » public·void·SetPlayer(PlayerControl·player) |
| 8 | » { | 8 | » { |
| 9 | » » this.SetPlayer(player.Data); | 9 | » » this.SetPlayer(player.Data); |
| 10 | » } | 10 | » } |
| 11 | 11 | ||
| 12 | » public·void·SetPlayer( | 12 | » public·void·SetPlayer(NetworkedPlayerInfo·playerInfo) |
| 13 | » { | 13 | » { |
| 14 | » » this.SetMaskLayer((int)playerInfo.PlayerId); | 14 | » » this.SetMaskLayer((int)playerInfo.PlayerId); |
| 15 | » » this.background.sprite·=·ShipStatus.Instance.CosmeticsCache.GetNameplate(playerInfo.DefaultOutfit.NamePlateId).Image; | 15 | » » this.background.sprite·=·ShipStatus.Instance.CosmeticsCache.GetNameplate(playerInfo.DefaultOutfit.NamePlateId).Image; |
| 16 | » » this.playerIcon.UpdateFromPlayerOutfit(playerInfo.Outfits[PlayerOutfitType.Default],·PlayerMaterial.MaskType.ComplexUI,·false,·false,·null,·false); | 16 | » » this.playerIcon.UpdateFromPlayerOutfit(playerInfo.Outfits[PlayerOutfitType.Default],·PlayerMaterial.MaskType.ComplexUI,·false,·false,·null,·false); |
| 17 | » » this.playerIcon.ToggleName(false); | 17 | » » this.playerIcon.ToggleName(false); |
| 18 | » » this.nameText.text·=·playerInfo.PlayerName; | 18 | » » this.nameText.text·=·playerInfo.PlayerName; |
| 19 | » » this.levelText.text·=·ProgressionManager.FormatVisualLevel(playerInfo.PlayerLevel); | 19 | » » this.levelText.text·=·ProgressionManager.FormatVisualLevel(playerInfo.PlayerLevel); |
| Offset 26, 21 lines modified | Offset 26, 21 lines modified | ||
| 26 | » » for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++) | 26 | » » for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++) |
| 27 | » » { | 27 | » » { |
| 28 | » » » componentsInChildren[i].material.SetInt(PlayerMaterial.MaskLayer,·num); | 28 | » » » componentsInChildren[i].material.SetInt(PlayerMaterial.MaskLayer,·num); |
| 29 | » » } | 29 | » » } |
| 30 | » » this.playerIcon.SetMaskLayer(num); | 30 | » » this.playerIcon.SetMaskLayer(num); |
| 31 | » } | 31 | » } |
| 32 | 32 | ||
| 33 | » [SerializeField] | ||
| 34 | » [Header("Nameplate")] | 33 | » [Header("Nameplate")] |
| 34 | » [SerializeField] | ||
| 35 | » private·PoolablePlayer·playerIcon; | 35 | » private·PoolablePlayer·playerIcon; |
| 36 | 36 | ||
| 37 | » [SerializeField] | 37 | » [SerializeField] |
| 38 | » private·SpriteRenderer·background; | 38 | » private·SpriteRenderer·background; |
| 39 | 39 | ||
| 40 | » [SerializeField] | ||
| 41 | » [Header("Text")] | 40 | » [Header("Text")] |
| 41 | » [SerializeField] | ||
| 42 | » private·TextMeshPro·nameText; | 42 | » private·TextMeshPro·nameText; |
| 43 | 43 | ||
| 44 | » [SerializeField] | 44 | » [SerializeField] |
| 45 | » private·TextMeshPro·levelText; | 45 | » private·TextMeshPro·levelText; |
| 46 | } | 46 | } |
| Offset 170, 29 lines modified | Offset 170, 29 lines modified | ||
| 170 | » » » mapOptions.ShowLivePlayerPosition·=·false; | 170 | » » » mapOptions.ShowLivePlayerPosition·=·false; |
| 171 | » » } | 171 | » » } |
| 172 | » » return·mapOptions; | 172 | » » return·mapOptions; |
| 173 | » } | 173 | » } |
| 174 | 174 | ||
| 175 | » private·void·CheckUpdateSurvivedStat() | 175 | » private·void·CheckUpdateSurvivedStat() |
| 176 | » { | 176 | » { |
| 177 | » » if·(! | 177 | » » if·(!EndGameResult.CachedLocalPlayer.IsDead·&&·!EndGameResult.CachedLocalPlayer.IsImpostor) |
| 178 | » » { | 178 | » » { |
| 179 | » » » StatsManager.Instance.IncrementStat(StringNames.StatsHidenSeekGamesCrewmateSurvived); | 179 | » » » StatsManager.Instance.IncrementStat(StringNames.StatsHidenSeekGamesCrewmateSurvived); |
| 180 | » » } | 180 | » » } |
| 181 | » } | 181 | » } |
| 182 | 182 | ||
| 183 | » private·void·CheckUpdateGameTimeStats() | 183 | » private·void·CheckUpdateGameTimeStats() |
| 184 | » { | 184 | » { |
| 185 | » » float·roundTimeElapsed·=·this.LogicFlowHnS.GetRoundTimeElapsed(); | 185 | » » float·roundTimeElapsed·=·this.LogicFlowHnS.GetRoundTimeElapsed(); |
| 186 | » » if·( | 186 | » » if·(EndGameResult.CachedLocalPlayer.IsImpostor·&&·this.DidImpostorsWin(EndGameResult.CachedGameOverReason)) |
| 187 | » » { | 187 | » » { |
| 188 | » » » StatsManager.Instance.UpdateHideAndSeekImpostorWinTimer(roundTimeElapsed); | 188 | » » » StatsManager.Instance.UpdateHideAndSeekImpostorWinTimer(roundTimeElapsed); |
| 189 | » » » return; | 189 | » » » return; |
| 190 | » » } | 190 | » » } |
| 191 | » » if·(! | 191 | » » if·(!EndGameResult.CachedLocalPlayer.IsImpostor·&&·this.DidHumansWin(EndGameResult.CachedGameOverReason)) |
| 192 | » » { | 192 | » » { |
| 193 | » » » StatsManager.Instance.UpdateHideAndSeekCrewmateWinTimer(roundTimeElapsed); | 193 | » » » StatsManager.Instance.UpdateHideAndSeekCrewmateWinTimer(roundTimeElapsed); |
| 194 | » » } | 194 | » » } |
| 195 | » } | 195 | » } |
| 196 | 196 | ||
| 197 | » public·override·bool·CanReportBodies() | 197 | » public·override·bool·CanReportBodies() |
| 198 | » { | 198 | » { |
| Offset 254, 14 lines modified | Offset 254, 14 lines modified | ||
| 254 | » private·Sprite·BrokenEmergencyButton; | 254 | » private·Sprite·BrokenEmergencyButton; |
| 255 | 255 | ||
| 256 | » [SerializeField] | 256 | » [SerializeField] |
| 257 | » private·DeadBody·horseBody; | 257 | » private·DeadBody·horseBody; |
| 258 | 258 | ||
| 259 | » private·TextMeshPro·someoneJustDiedText; | 259 | » private·TextMeshPro·someoneJustDiedText; |
| 260 | 260 | ||
| 261 | » private· | 261 | » private·NetworkedPlayerInfo.PlayerOutfit·horseWranglerOutfit·=·new·NetworkedPlayerInfo.PlayerOutfit |
| 262 | » { | 262 | » { |
| 263 | » » HatId·=·"hat_Starless", | 263 | » » HatId·=·"hat_Starless", |
| 264 | » » SkinId·=·"skin_MilitaryDesert", | 264 | » » SkinId·=·"skin_MilitaryDesert", |
| 265 | » » VisorId·=·"visor_WinstonStache" | 265 | » » VisorId·=·"visor_WinstonStache" |
| 266 | » }; | 266 | » }; |
| 267 | } | 267 | } |
| Offset 133, 32 lines modified | Offset 133, 32 lines modified | ||
| 133 | » private·Collider2D·draggable; | 133 | » private·Collider2D·draggable; |
| 134 | 134 | ||
| 135 | » [Header("Input")] | 135 | » [Header("Input")] |
| 136 | » [SerializeField] | 136 | » [SerializeField] |
| 137 | » [Tooltip("The·difficulty·of·the·hoist·minigame,·increasing·as·the·target·gets·closer·to·completion.")] | 137 | » [Tooltip("The·difficulty·of·the·hoist·minigame,·increasing·as·the·target·gets·closer·to·completion.")] |
| 138 | » private·AnimationCurve·liftMultiplierCurve; | 138 | » private·AnimationCurve·liftMultiplierCurve; |
| 139 | 139 | ||
| 140 | » [SerializeField] | ||
| 141 | » [Range(0.01f,·4f)] | ||
| 142 | » [Tooltip("The·forced·delay·(in·seconds)·between·each·hoist·controller·button·press.·Players·cannot·press·the·hoist·button·faster·than·this.")] | 140 | » [Tooltip("The·forced·delay·(in·seconds)·between·each·hoist·controller·button·press.·Players·cannot·press·the·hoist·button·faster·than·this.")] |
| 141 | » [Range(0.01f,·4f)] | ||
| 142 | » [SerializeField] | ||
| 143 | » private·float·controllerButtonDelay·=·0.2f; | 143 | » private·float·controllerButtonDelay·=·0.2f; |
| 144 | 144 | ||
| 145 | » [Range(0.01f,·2f)] | 145 | » [Range(0.01f,·2f)] |
| 146 | » [Tooltip("The·amount·added·every·time·a·controller·button·is·pressed·(Multiplied·by·the·liftMultiplierCurve)")] | ||
| 147 | » [SerializeField] | 146 | » [SerializeField] |
| 147 | » [Tooltip("The·amount·added·every·time·a·controller·button·is·pressed·(Multiplied·by·the·liftMultiplierCurve)")] | ||
| 148 | » private·float·controllerRaiseAmount·=·0.4f; | 148 | » private·float·controllerRaiseAmount·=·0.4f; |
| 149 | 149 | ||
| 150 | » [Tooltip("The·amount·of·offset·to·add·to·the·pull-rope·every·time·the·controller·pull·button·is·pressed")] | ||
| 151 | » [Range(0.01f,·2f)] | 150 | » [Range(0.01f,·2f)] |
| 151 | » [Tooltip("The·amount·of·offset·to·add·to·the·pull-rope·every·time·the·controller·pull·button·is·pressed")] | ||
| 152 | » [SerializeField] | 152 | » [SerializeField] |
| 153 | » private·float·controllerPullAmount·=·0.4f; | 153 | » private·float·controllerPullAmount·=·0.4f; |
| 154 | 154 | ||
| 155 | » [Tooltip("The·Speed·at·which·the·hoisted·sprite·animates·to·it's·intended·offset·each·time·the·controller·pull·button·is·pressed.·(Recommended·between·the·3-15·range)")] | ||
| 155 | » [Header("Animation·Speeds")] | 156 | » [Header("Animation·Speeds")] |
| 156 | » [SerializeField] | 157 | » [SerializeField] |
| 157 | » [Tooltip("The·Speed·at·which·the·hoisted·sprite·animates·to·it's·intended·offset·each·time·the·controller·pull·button·is·pressed.·(Recommended·between·the·3-15·range)")] | ||
| 158 | » private·float·raiseAnimSpeed·=·5f; | 158 | » private·float·raiseAnimSpeed·=·5f; |
| 159 | 159 | ||
| 160 | » [SerializeField] | 160 | » [SerializeField] |
| 161 | » [Tooltip("The·Speed·at·which·the·pull-rope·animates·to·it's·intended·offset·each·time·the·controller·pull·button·is·pressed.·(Recommended·between·the·3-15·range)")] | 161 | » [Tooltip("The·Speed·at·which·the·pull-rope·animates·to·it's·intended·offset·each·time·the·controller·pull·button·is·pressed.·(Recommended·between·the·3-15·range)")] |
| 162 | » private·float·pullAnimSpeed·=·5f; | 162 | » private·float·pullAnimSpeed·=·5f; |
| 163 | 163 | ||
| 164 | » [SerializeField] | 164 | » [SerializeField] |
| Offset 193, 16 lines modified | Offset 193, 16 lines modified | ||
| 193 | 193 | ||
| 194 | » [SerializeField] | 194 | » [SerializeField] |
| 195 | » private·Vector3·draggableRopeBottomPos; | 195 | » private·Vector3·draggableRopeBottomPos; |
| 196 | 196 | ||
| 197 | » [SerializeField] | 197 | » [SerializeField] |
| 198 | » private·Transform·ropeTexture; | 198 | » private·Transform·ropeTexture; |
| 199 | 199 | ||
| 200 | » [Header("Lights")] | ||
| 201 | » [SerializeField] | 200 | » [SerializeField] |
| 201 | » [Header("Lights")] | ||
| 202 | » private·GameObject·redCircle; | 202 | » private·GameObject·redCircle; |
| 203 | 203 | ||
| 204 | » [SerializeField] | 204 | » [SerializeField] |
| 205 | » private·GameObject·greenCircle; | 205 | » private·GameObject·greenCircle; |
| 206 | 206 | ||
| 207 | » [SerializeField] | 207 | » [SerializeField] |
| 208 | » [Header("Controller·Hint")] | 208 | » [Header("Controller·Hint")] |
| Offset 2, 15 lines modified | Offset 2, 15 lines modified | ||
| 2 | using·System.Collections; | 2 | using·System.Collections; |
| 3 | using·UnityEngine; | 3 | using·UnityEngine; |
| 4 | 4 | ||
| 5 | public·class·HorseWrangleOverlay·:·OverlayKillAnimation | 5 | public·class·HorseWrangleOverlay·:·OverlayKillAnimation |
| 6 | { | 6 | { |
| 7 | » public·override·IEnumerator·CoShow(KillOverlay·parent) | 7 | » public·override·IEnumerator·CoShow(KillOverlay·parent) |
| 8 | » { | 8 | » { |
| 9 | » » this.victimParts.SetHat | 9 | » » this.victimParts.SetHatOnFloor(); |
| 10 | » » PlayerMaterial.SetColors(this.killerParts.ColorId,·this.impostorForeground); | 10 | » » PlayerMaterial.SetColors(this.killerParts.ColorId,·this.impostorForeground); |
| 11 | » » PlayerMaterial.SetColors(this.killerParts.ColorId,·this.impostorHand); | 11 | » » PlayerMaterial.SetColors(this.killerParts.ColorId,·this.impostorHand); |
| 12 | » » this.victimSprites.ForEach(delegate(SpriteRenderer·b) | 12 | » » this.victimSprites.ForEach(delegate(SpriteRenderer·b) |
| 13 | » » { | 13 | » » { |
| 14 | » » » PlayerMaterial.SetColors(this.victimParts.ColorId,·b); | 14 | » » » PlayerMaterial.SetColors(this.victimParts.ColorId,·b); |
| 15 | » » }); | 15 | » » }); |
| 16 | » » yield·return·base.CoShow(parent); | 16 | » » yield·return·base.CoShow(parent); |
| Offset 9, 18 lines modified | Offset 9, 14 lines modified | ||
| 9 | » public·void·Start() | 9 | » public·void·Start() |
| 10 | » { | 10 | » { |
| 11 | » » this.category·=·HowToPlayScene.HowToPlayCategory.None; | 11 | » » this.category·=·HowToPlayScene.HowToPlayCategory.None; |
| 12 | » » this.arrows.SetActive(false); | 12 | » » this.arrows.SetActive(false); |
| 13 | » » this.startPage.SetActive(true); | 13 | » » this.startPage.SetActive(true); |
| 14 | » » ControllerManager.Instance.NewScene(base.name,·this.closeButton,·this.defaultButtonSelected,·this.controllerSelectables,·false); | 14 | » » ControllerManager.Instance.NewScene(base.name,·this.closeButton,·this.defaultButtonSelected,·this.controllerSelectables,·false); |
| 15 | » » this.SetupDots(0); | 15 | » » this.SetupDots(0); |
| 16 | » » if·(!DataManager.Player.Onboarding.ViewedHideAndSeekHowToPlay) | ||
| 17 | » » { | ||
| 18 | » » » this.StartHideAndSeek(); | ||
| 19 | » » } | ||
| 20 | » } | 16 | » } |
| 21 | 17 | ||
| 22 | » public·void·StartClassic() | 18 | » public·void·StartClassic() |
| 23 | » { | 19 | » { |
| 24 | » » this.sceneIndex·=·0; | 20 | » » this.sceneIndex·=·0; |
| 25 | » » this.category·=·HowToPlayScene.HowToPlayCategory.GameMode_Classic; | 21 | » » this.category·=·HowToPlayScene.HowToPlayCategory.GameMode_Classic; |
| 26 | » » this.startPage.SetActive(false); | 22 | » » this.startPage.SetActive(false); |
| Offset 171, 15 lines modified | Offset 167, 15 lines modified | ||
| 171 | » » this.closeButton.gameObject.SetActive(this.CanClose()); | 167 | » » this.closeButton.gameObject.SetActive(this.CanClose()); |
| 172 | » » this.SetActiveDot(this.sceneIndex); | 168 | » » this.SetActiveDot(this.sceneIndex); |
| 173 | » » this.leftButton.gameObject.SetActive(this.sceneIndex·>·0); | 169 | » » this.leftButton.gameObject.SetActive(this.sceneIndex·>·0); |
| 174 | » } | 170 | » } |
| 175 | 171 | ||
| 176 | » private·bool·CanClose() | 172 | » private·bool·CanClose() |
| 177 | » { | 173 | » { |
| 178 | » » return·t | 174 | » » return·true; |
| 179 | » } | 175 | » } |
| 180 | 176 | ||
| 181 | » private·void·SetupDots(int·count) | 177 | » private·void·SetupDots(int·count) |
| 182 | » { | 178 | » { |
| 183 | » » if·(this.dots·!=·null) | 179 | » » if·(this.dots·!=·null) |
| 184 | » » { | 180 | » » { |
| 185 | » » » Transform[]·array·=·this.dots; | 181 | » » » Transform[]·array·=·this.dots; |
| Offset 216, 41 lines modified | Offset 212, 41 lines modified | ||
| 216 | » » » return; | 212 | » » » return; |
| 217 | » » } | 213 | » » } |
| 218 | » » this.dots[index].localScale·=·new·Vector3(1.5f,·1.5f,·1.5f); | 214 | » » this.dots[index].localScale·=·new·Vector3(1.5f,·1.5f,·1.5f); |
| 219 | » } | 215 | » } |
| 220 | 216 | ||
| 221 | » public·static·string·SceneOnClose; | 217 | » public·static·string·SceneOnClose; |
| 222 | 218 | ||
| 223 | » [Header("UI")] | ||
| 224 | » [SerializeField] | 219 | » [SerializeField] |
| 220 | » [Header("UI")] | ||
| 225 | » private·GameObject·startPage; | 221 | » private·GameObject·startPage; |
| 226 | 222 | ||
| 227 | » [SerializeField] | ||
| 228 | » [Space(10f)] | 223 | » [Space(10f)] |
| 224 | » [SerializeField] | ||
| 229 | » private·GameObject·arrows; | 225 | » private·GameObject·arrows; |
| 230 | 226 | ||
| 231 | » [SerializeField] | 227 | » [SerializeField] |
| 232 | » private·SpriteRenderer·leftButton; | 228 | » private·SpriteRenderer·leftButton; |
| 233 | 229 | ||
| 234 | » [SerializeField] | 230 | » [SerializeField] |
| 235 | » private·SpriteRenderer·rightButton; | 231 | » private·SpriteRenderer·rightButton; |
| 236 | 232 | ||
| 237 | » [SerializeField] | 233 | » [SerializeField] |
| 238 | » [Space(10f)] | 234 | » [Space(10f)] |
| 239 | » private·UiElement·closeButton; | 235 | » private·UiElement·closeButton; |
| 240 | 236 | ||
| 241 | » [SerializeField] | ||
| 242 | » [Space(10f)] | 237 | » [Space(10f)] |
| 238 | » [SerializeField] | ||
| 243 | » private·Transform·dotParent; | 239 | » private·Transform·dotParent; |
| 244 | 240 | ||
| 245 | » [SerializeField] | 241 | » [SerializeField] |
| 246 | » private·Transform·dotTemplate; | 242 | » private·Transform·dotTemplate; |
| 247 | 243 | ||
| 248 | » [SerializeField] | ||
| 249 | » [Header("Game·Mode·Scenes")] | 244 | » [Header("Game·Mode·Scenes")] |
| 245 | » [SerializeField] | ||
| 250 | » private·AbstractHowToPlayScenePage[]·classicScenes; | 246 | » private·AbstractHowToPlayScenePage[]·classicScenes; |
| 251 | 247 | ||
| 252 | » [SerializeField] | 248 | » [SerializeField] |
| 253 | » private·AbstractHowToPlayScenePage[]·hideAndSeekScenes; | 249 | » private·AbstractHowToPlayScenePage[]·hideAndSeekScenes; |
| 254 | 250 | ||
| 255 | » [SerializeField] | 251 | » [SerializeField] |
| 256 | » [Space(10f)] | 252 | » [Space(10f)] |
| Offset 1, 15 lines modified | Offset 1, 14 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections; | 2 | using·System.Collections; |
| 3 | using·System.Linq; | 3 | using·System.Linq; |
| 4 | using·System.Text; | 4 | using·System.Text; |
| 5 | using·AmongUs.Data; | 5 | using·AmongUs.Data; |
| 6 | using·AmongUs.GameOptions; | 6 | using·AmongUs.GameOptions; |
| 7 | using·InnerNet; | 7 | using·InnerNet; |
| 8 | using·TMPro; | ||
| 9 | using·UnityEngine; | 8 | using·UnityEngine; |
| 10 | 9 | ||
| 11 | public·class·HudManager·:·DestroyableSingleton<HudManager> | 10 | public·class·HudManager·:·DestroyableSingleton<HudManager> |
| 12 | { | 11 | { |
| 13 | » public·Coroutine·ReactorFlash·{·get;·set;·} | 12 | » public·Coroutine·ReactorFlash·{·get;·set;·} |
| 14 | 13 | ||
| 15 | » public·Coroutine·OxyFlash·{·get;·set;·} | 14 | » public·Coroutine·OxyFlash·{·get;·set;·} |
| Offset 116, 14 lines modified | Offset 115, 19 lines modified | ||
| 116 | » » if·(!MapBehaviour.Instance) | 115 | » » if·(!MapBehaviour.Instance) |
| 117 | » » { | 116 | » » { |
| 118 | » » » MapBehaviour.Instance·=·Object.Instantiate<MapBehaviour>(ShipStatus.Instance.MapPrefab,·base.transform); | 117 | » » » MapBehaviour.Instance·=·Object.Instantiate<MapBehaviour>(ShipStatus.Instance.MapPrefab,·base.transform); |
| 119 | » » » MapBehaviour.Instance.gameObject.SetActive(false); | 118 | » » » MapBehaviour.Instance.gameObject.SetActive(false); |
| 120 | » » } | 119 | » » } |
| 121 | » } | 120 | » } |
| 122 | 121 | ||
| 122 | » public·void·DeselectMapButton() | ||
| 123 | » { | ||
| 124 | » » this.MapButton.SelectButton(false); | ||
| 125 | » } | ||
| 126 | |||
| 123 | » public·void·ToggleMapVisible(MapOptions·options) | 127 | » public·void·ToggleMapVisible(MapOptions·options) |
| 124 | » { | 128 | » { |
| 125 | » » if·(MapBehaviour.Instance·&&·MapBehaviour.Instance.gameObject.activeSelf) | 129 | » » if·(MapBehaviour.Instance·&&·MapBehaviour.Instance.gameObject.activeSelf) |
| 126 | » » { | 130 | » » { |
| 127 | » » » MapBehaviour.Instance.Close(); | 131 | » » » MapBehaviour.Instance.Close(); |
| 128 | » » » return; | 132 | » » » return; |
| 129 | » » } | 133 | » » } |
| Offset 133, 14 lines modified | Offset 137, 15 lines modified | ||
| 133 | » » } | 137 | » » } |
| 134 | » » if·(!ShipStatus.Instance) | 138 | » » if·(!ShipStatus.Instance) |
| 135 | » » { | 139 | » » { |
| 136 | » » » return; | 140 | » » » return; |
| 137 | » » } | 141 | » » } |
| 138 | » » this.InitMap(); | 142 | » » this.InitMap(); |
| 139 | » » MapBehaviour.Instance.Show(options); | 143 | » » MapBehaviour.Instance.Show(options); |
| 144 | » » this.MapButton.SelectButton(true); | ||
| 140 | » } | 145 | » } |
| 141 | 146 | ||
| 142 | » public·void·SetHudActive(PlayerControl·localPlayer,·RoleBehaviour·role,·bool·isActive) | 147 | » public·void·SetHudActive(PlayerControl·localPlayer,·RoleBehaviour·role,·bool·isActive) |
| 143 | » { | 148 | » { |
| 144 | » » this.AbilityButton.ToggleVisible(isActive); | 149 | » » this.AbilityButton.ToggleVisible(isActive); |
| 145 | » » if·(isActive) | 150 | » » if·(isActive) |
| 146 | » » { | 151 | » » { |
| Offset 148, 17 lines modified | Offset 153, 17 lines modified | ||
| 148 | » » » this.AbilityButton.Refresh(role.Ability); | 153 | » » » this.AbilityButton.Refresh(role.Ability); |
| 149 | » » } | 154 | » » } |
| 150 | » » else | 155 | » » else |
| 151 | » » { | 156 | » » { |
| 152 | » » » this.UseButton.ToggleVisible(false); | 157 | » » » this.UseButton.ToggleVisible(false); |
| 153 | » » » this.PetButton.ToggleVisible(false); | 158 | » » » this.PetButton.ToggleVisible(false); |
| 154 | » » } | 159 | » » } |
| 155 | » » bool·flag·=·localPlayer.Data· | 160 | » » bool·flag·=·!(localPlayer.Data·==·null)·&&·localPlayer.Data.IsDead; |
| 156 | » » this.ReportButton.ToggleVisible(isActive·&&·!flag·&&·GameManager.Instance.CanReportBodies()·&&·ShipStatus.Instance·!=·null); | 161 | » » this.ReportButton.ToggleVisible(isActive·&&·!flag·&&·GameManager.Instance.CanReportBodies()·&&·ShipStatus.Instance·!=·null); |
| 157 | » » this.KillButton.ToggleVisible(isActive·&&·role.IsImpostor·&&·!flag); | 162 | » » this.KillButton.ToggleVisible(isActive·&&·role.IsImpostor·&&·role.CanUseKillButton·&&·!flag); |
| 158 | » » this.SabotageButton.ToggleVisible(isActive·&&·role.IsImpostor); | 163 | » » this.SabotageButton.ToggleVisible(isActive·&&·role.IsImpostor); |
| 159 | » » this.AdminButton.ToggleVisible(isActive·&&·role.IsImpostor); | 164 | » » this.AdminButton.ToggleVisible(isActive·&&·role.IsImpostor); |
| 160 | » » this.ImpostorVentButton.ToggleVisible(isActive·&&·!flag·&&·role.IsImpostor·&&·GameOptionsManager.Instance.CurrentGameOptions.GameMode·!=·GameModes.HideNSeek); | 165 | » » this.ImpostorVentButton.ToggleVisible(isActive·&&·!flag·&&·role.IsImpostor·&&·GameOptionsManager.Instance.CurrentGameOptions.GameMode·!=·GameModes.HideNSeek); |
| 161 | » » this.TaskPanel.gameObject.SetActive(isActive); | 166 | » » this.TaskPanel.gameObject.SetActive(isActive); |
| 162 | » » this.roomTracker.gameObject.SetActive(isActive); | 167 | » » this.roomTracker.gameObject.SetActive(isActive); |
| 163 | » » if·(this.joystick·!=·null) | 168 | » » if·(this.joystick·!=·null) |
| 164 | » » { | 169 | » » { |
| Offset 204, 25 lines modified | Offset 209, 29 lines modified | ||
| 204 | » { | 209 | » { |
| 205 | » » if·(this.consoleUIRoot.transform.localPosition.x·!=·this.consoleUIHorizontalShift) | 210 | » » if·(this.consoleUIRoot.transform.localPosition.x·!=·this.consoleUIHorizontalShift) |
| 206 | » » { | 211 | » » { |
| 207 | » » » Vector3·localPosition·=·this.consoleUIRoot.transform.localPosition; | 212 | » » » Vector3·localPosition·=·this.consoleUIRoot.transform.localPosition; |
| 208 | » » » localPosition.x·=·this.consoleUIHorizontalShift; | 213 | » » » localPosition.x·=·this.consoleUIHorizontalShift; |
| 209 | » » » this.consoleUIRoot.transform.localPosition·=·localPosition; | 214 | » » » this.consoleUIRoot.transform.localPosition·=·localPosition; |
| 210 | » » } | 215 | » » } |
| 216 | » » if·(this.joystickR·!=·null·&&·LobbyBehaviour.Instance·!=·null) | ||
| 217 | » » { | ||
| 218 | » » » this.joystickR.ToggleVisuals(false); | ||
| 219 | » » } | ||
| 211 | » » this.taskDirtyTimer·+=·Time.deltaTime; | 220 | » » this.taskDirtyTimer·+=·Time.deltaTime; |
| 212 | » » if·(this.taskDirtyTimer·>·0.25f) | 221 | » » if·(this.taskDirtyTimer·>·0.25f) |
| 213 | » » { | 222 | » » { |
| 214 | » » » float·num·=·this.taskDirtyTimer; | 223 | » » » float·num·=·this.taskDirtyTimer; |
| 215 | » » » this.taskDirtyTimer·=·0f; | 224 | » » » this.taskDirtyTimer·=·0f; |
| 216 | » » » if·(!PlayerControl.LocalPlayer) | 225 | » » » if·(!PlayerControl.LocalPlayer) |
| 217 | » » » { | 226 | » » » { |
| 218 | » » » » this.TaskPanel.SetTaskText(string.Empty); | 227 | » » » » this.TaskPanel.SetTaskText(string.Empty); |
| 219 | » » » » return; | 228 | » » » » return; |
| 220 | » » » } | 229 | » » » } |
| 221 | » » » | 230 | » » » NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data; |
| 222 | » » » if·(data·==·null) | 231 | » » » if·(data·==·null) |
| 223 | » » » { | 232 | » » » { |
| 224 | » » » » return; | 233 | » » » » return; |
| 225 | » » » } | 234 | » » » } |
| 226 | » » » bool·flag·=·data.Role·!=·null·&&·data.Role.IsImpostor; | 235 | » » » bool·flag·=·data.Role·!=·null·&&·data.Role.IsImpostor; |
| 227 | » » » this.tasksString.Clear(); | 236 | » » » this.tasksString.Clear(); |
| 228 | » » » if·(PlayerControl.LocalPlayer.myTasks·==·null·||·PlayerControl.LocalPlayer.myTasks.Count·==·0) | 237 | » » » if·(PlayerControl.LocalPlayer.myTasks·==·null·||·PlayerControl.LocalPlayer.myTasks.Count·==·0) |
| Offset 428, 15 lines modified | Offset 437, 15 lines modified | ||
| 428 | » » » return; | 437 | » » » return; |
| 429 | » » } | 438 | » » } |
| 430 | » » Debug.Log("Opening·meeting·room:·"·+·((reporter·!=·null)·?·reporter.ToString()·:·null)); | 439 | » » Debug.Log("Opening·meeting·room:·"·+·((reporter·!=·null)·?·reporter.ToString()·:·null)); |
| 431 | » » ShipStatus.Instance.RepairCriticalSabotages(); | 440 | » » ShipStatus.Instance.RepairCriticalSabotages(); |
| 432 | » » MeetingHud.Instance·=·Object.Instantiate<MeetingHud>(this.MeetingPrefab); | 441 | » » MeetingHud.Instance·=·Object.Instantiate<MeetingHud>(this.MeetingPrefab); |
| 433 | » » MeetingHud.Instance.ServerStart(reporter.PlayerId); | 442 | » » MeetingHud.Instance.ServerStart(reporter.PlayerId); |
| 434 | » » AmongUsClient.Instance.Spawn(MeetingHud.Instance,·-2,·SpawnFlags.None); | 443 | » » AmongUsClient.Instance.Spawn(MeetingHud.Instance,·-2,·SpawnFlags.None); |
| 435 | » » | 444 | » » GameData.OnMeetingStart(); |
| 436 | » » this.Chat.OnMeetingStart(); | 445 | » » this.Chat.OnMeetingStart(); |
| 437 | » } | 446 | » } |
| 438 | 447 | ||
| 439 | » public·void·SetAlertOverlay(bool·enabled) | 448 | » public·void·SetAlertOverlay(bool·enabled) |
| 440 | » { | 449 | » { |
| 441 | » » this.AlertFlash.SetOverlay(enabled); | 450 | » » this.AlertFlash.SetOverlay(enabled); |
| 442 | » } | 451 | » } |
| Offset 538, 16 lines modified | Offset 547, 14 lines modified | ||
| 538 | 547 | ||
| 539 | » public·PetButton·PetButton; | 548 | » public·PetButton·PetButton; |
| 540 | 549 | ||
| 541 | » public·AbilityButton·AbilityButton; | 550 | » public·AbilityButton·AbilityButton; |
| 542 | 551 | ||
| 543 | » public·ReportButton·ReportButton; | 552 | » public·ReportButton·ReportButton; |
| 544 | 553 | ||
| 545 | » public·TextMeshPro·GameSettings; | ||
| 546 | |||
| 547 | » public·GameObject·TaskStuff; | 554 | » public·GameObject·TaskStuff; |
| 548 | 555 | ||
| Max diff block lines reached; 87/4323 bytes (2.01%) of diff not shown. | |||
| Offset 1, 28 lines modified | Offset 1, 28 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections.Generic; | 2 | using·System.Collections.Generic; |
| 3 | using·AmongUs.GameOptions; | 3 | using·AmongUs.GameOptions; |
| 4 | 4 | ||
| 5 | public·interface·IAnalyticsReporter | 5 | public·interface·IAnalyticsReporter |
| 6 | { | 6 | { |
| 7 | » void·StartGame( | 7 | » void·StartGame(NetworkedPlayerInfo·localPlayer,·int·playerCount,·int·impostorCount,·NetworkModes·networkMode,·MapNames·map,·GameModes·gameMode,·string·roomCode,·string·serverName,·IGameOptions·options,·List<NetworkedPlayerInfo>·players); |
| 8 | 8 | ||
| 9 | » void·EndGame(float·durationInSeconds,·GameOverReason·endReason,·List< | 9 | » void·EndGame(float·durationInSeconds,·GameOverReason·endReason,·List<NetworkedPlayerInfo>·players); |
| 10 | 10 | ||
| 11 | » void·VentUsed( | 11 | » void·VentUsed(NetworkedPlayerInfo·player); |
| 12 | 12 | ||
| 13 | » void·Kill( | 13 | » void·Kill(NetworkedPlayerInfo·victim,·NetworkedPlayerInfo·killer); |
| 14 | 14 | ||
| 15 | » void·SabotageStart(SystemTypes·type); | 15 | » void·SabotageStart(SystemTypes·type); |
| 16 | 16 | ||
| 17 | » void·SabotageFixed(SystemTypes·type); | 17 | » void·SabotageFixed(SystemTypes·type); |
| 18 | 18 | ||
| 19 | » void·TaskCompleted( | 19 | » void·TaskCompleted(NetworkedPlayerInfo·player,·PlayerTask·task); |
| 20 | 20 | ||
| 21 | » void·MeetingStarted( | 21 | » void·MeetingStarted(NetworkedPlayerInfo·callingPlayer,·bool·bodyReported); |
| 22 | 22 | ||
| 23 | » void·MeetingEnded(float·durationInSeconds,· | 23 | » void·MeetingEnded(float·durationInSeconds,·NetworkedPlayerInfo·playerEjected); |
| 24 | 24 | ||
| 25 | » void·MinigameOpened( | 25 | » void·MinigameOpened(NetworkedPlayerInfo·callingPlayer,·TaskTypes·task); |
| 26 | 26 | ||
| 27 | » void·MinigameClosed( | 27 | » void·MinigameClosed(NetworkedPlayerInfo·callingPlayer,·TaskTypes·task,·float·durationInSeconds,·bool·isCompleted); |
| 28 | } | 28 | } |
| Offset 1, 8 lines modified | Offset 1, 10 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | 2 | ||
| 3 | public·interface·IDisconnectHandler | 3 | public·interface·IDisconnectHandler |
| 4 | { | 4 | { |
| 5 | » bool·IsPersistent·{·get;·} | ||
| 6 | |||
| 5 | » void·HandleDisconnect(PlayerControl·pc,·DisconnectReasons·reason); | 7 | » void·HandleDisconnect(PlayerControl·pc,·DisconnectReasons·reason); |
| 6 | 8 | ||
| 7 | » void·HandleDisconnect(); | 9 | » void·HandleDisconnect(); |
| 8 | } | 10 | } |
| Offset 8, 14 lines modified | Offset 8, 21 lines modified | ||
| 8 | » public·static·void·SetRecommendations(this·IGameOptions·gameOptions,·int·numPlayers,·NetworkModes·modes) | 8 | » public·static·void·SetRecommendations(this·IGameOptions·gameOptions,·int·numPlayers,·NetworkModes·modes) |
| 9 | » { | 9 | » { |
| 10 | » » numPlayers·=·Mathf.Clamp(numPlayers,·4,·15); | 10 | » » numPlayers·=·Mathf.Clamp(numPlayers,·4,·15); |
| 11 | » » bool·flag·=·modes·==·NetworkModes.OnlineGame; | 11 | » » bool·flag·=·modes·==·NetworkModes.OnlineGame; |
| 12 | » » gameOptions.SetRecommendations(numPlayers,·flag); | 12 | » » gameOptions.SetRecommendations(numPlayers,·flag); |
| 13 | » } | 13 | » } |
| 14 | 14 | ||
| 15 | » public·static·void·SetRecommendations(this·IGameOptions·gameOptions,·int·numPlayers,·NetworkModes·modes,·RulesPresets·rulesPresets) | ||
| 16 | » { | ||
| 17 | » » numPlayers·=·Mathf.Clamp(numPlayers,·4,·15); | ||
| 18 | » » bool·flag·=·modes·==·NetworkModes.OnlineGame; | ||
| 19 | » » gameOptions.SetRecommendations(numPlayers,·flag,·rulesPresets); | ||
| 20 | » } | ||
| 21 | |||
| 15 | » public·static·int·GetAdjustedNumImpostors(this·IGameOptions·gameOptions,·int·playerCount) | 22 | » public·static·int·GetAdjustedNumImpostors(this·IGameOptions·gameOptions,·int·playerCount) |
| 16 | » { | 23 | » { |
| 17 | » » int·numImpostors·=·GameOptionsManager.Instance.CurrentGameOptions.NumImpostors; | 24 | » » int·numImpostors·=·GameOptionsManager.Instance.CurrentGameOptions.NumImpostors; |
| 18 | » » int·num·=·3; | 25 | » » int·num·=·3; |
| 19 | » » int[]·intArray·=·gameOptions.GetIntArray(Int32ArrayOptionNames.MaxImpostors); | 26 | » » int[]·intArray·=·gameOptions.GetIntArray(Int32ArrayOptionNames.MaxImpostors); |
| 20 | » » if·(intArray·!=·null·&&·GameData.Instance.PlayerCount·<·intArray.Length) | 27 | » » if·(intArray·!=·null·&&·GameData.Instance.PlayerCount·<·intArray.Length) |
| 21 | » » { | 28 | » » { |
| Offset 35, 14 lines modified | Offset 42, 62 lines modified | ||
| 35 | 42 | ||
| 36 | » public·static·bool·FilterContainsMap(this·IGameOptions·gameOptions,·byte·newId) | 43 | » public·static·bool·FilterContainsMap(this·IGameOptions·gameOptions,·byte·newId) |
| 37 | » { | 44 | » { |
| 38 | » » int·num·=·1·<<·(int)newId; | 45 | » » int·num·=·1·<<·(int)newId; |
| 39 | » » return·((int)gameOptions.MapId·&·num)·==·num; | 46 | » » return·((int)gameOptions.MapId·&·num)·==·num; |
| 40 | » } | 47 | » } |
| 41 | 48 | ||
| 49 | » public·static·float·GetValue(this·IGameOptions·gameOptions,·BaseGameSetting·data) | ||
| 50 | » { | ||
| 51 | » » float·num·=·-1f; | ||
| 52 | » » int·num2·=·-1; | ||
| 53 | » » bool·flag·=·false; | ||
| 54 | » » bool·flag2·=·false; | ||
| 55 | » » switch·(data.Type) | ||
| 56 | » » { | ||
| 57 | » » case·OptionTypes.Checkbox: | ||
| 58 | » » » gameOptions.TryGetBool((data·as·CheckboxGameSetting).OptionName,·out·flag); | ||
| 59 | » » » flag2·=·true; | ||
| 60 | » » » goto·IL_00E7; | ||
| 61 | » » case·OptionTypes.String: | ||
| 62 | » » » gameOptions.TryGetInt((data·as·StringGameSetting).OptionName,·out·num2); | ||
| 63 | » » » goto·IL_00E7; | ||
| 64 | » » case·OptionTypes.Float: | ||
| 65 | » » » gameOptions.TryGetFloat((data·as·FloatGameSetting).OptionName,·out·num); | ||
| 66 | » » » goto·IL_00E7; | ||
| 67 | » » case·OptionTypes.Int: | ||
| 68 | » » » gameOptions.TryGetInt((data·as·IntGameSetting).OptionName,·out·num2); | ||
| 69 | » » » goto·IL_00E7; | ||
| 70 | » » case·OptionTypes.Player: | ||
| 71 | » » » gameOptions.TryGetInt((data·as·PlayerSelectionGameSetting).OptionName,·out·num2); | ||
| 72 | » » » goto·IL_00E7; | ||
| 73 | » » case·OptionTypes.Map: | ||
| 74 | » » { | ||
| 75 | » » » MapSelectionGameSetting·mapSelectionGameSetting·=·data·as·MapSelectionGameSetting; | ||
| 76 | » » » if·(mapSelectionGameSetting·==·null) | ||
| 77 | » » » { | ||
| 78 | » » » » goto·IL_00E7; | ||
| 79 | » » » } | ||
| 80 | » » » mapSelectionGameSetting.TryGetInt(gameOptions,·out·num2); | ||
| 81 | » » » goto·IL_00E7; | ||
| 82 | » » } | ||
| 83 | » » } | ||
| 84 | » » Debug.LogError("Could·not·parse·type·of·"·+·data.Title.ToString()); | ||
| 85 | » » IL_00E7: | ||
| 86 | » » if·(num·==·-1f·&&·num2·!=·-1) | ||
| 87 | » » { | ||
| 88 | » » » num·=·(float)num2; | ||
| 89 | » » } | ||
| 90 | » » else·if·(num·==·-1f·&&·flag2) | ||
| 91 | » » { | ||
| 92 | » » » num·=·(float)((!flag)·?·0·:·1); | ||
| 93 | » » } | ||
| 94 | » » return·num; | ||
| 95 | » } | ||
| 96 | |||
| 42 | » public·static·string·ToHudString(this·IGameOptions·gameOptions,·int·numPlayers) | 97 | » public·static·string·ToHudString(this·IGameOptions·gameOptions,·int·numPlayers) |
| 43 | » { | 98 | » { |
| 44 | » » int[]·array; | 99 | » » int[]·array; |
| 45 | » » if·(!gameOptions.TryGetIntArray(Int32ArrayOptionNames.MaxImpostors,·out·array)) | 100 | » » if·(!gameOptions.TryGetIntArray(Int32ArrayOptionNames.MaxImpostors,·out·array)) |
| 46 | » » { | 101 | » » { |
| 47 | » » » Debug.LogError("Failed·to·generate·HUD·string·for·game·options,·no·MaxImpostors·array·found"); | 102 | » » » Debug.LogError("Failed·to·generate·HUD·string·for·game·options,·no·MaxImpostors·array·found"); |
| 48 | » » » return·"hud·string·generation·failed"; | 103 | » » » return·"hud·string·generation·failed"; |
| Offset 180, 27 lines modified | Offset 235, 41 lines modified | ||
| 180 | » » int·id·=·options.GetInt(Int32OptionNames.ImpostorPlayerID); | 235 | » » int·id·=·options.GetInt(Int32OptionNames.ImpostorPlayerID); |
| 181 | » » if·(id·<·0·||·isGamePublic) | 236 | » » if·(id·<·0·||·isGamePublic) |
| 182 | » » { | 237 | » » { |
| 183 | » » » settings.Append(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoundRobin,·Array.Empty<object>())); | 238 | » » » settings.Append(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoundRobin,·Array.Empty<object>())); |
| 184 | » » } | 239 | » » } |
| 185 | » » else | 240 | » » else |
| 186 | » » { | 241 | » » { |
| 187 | » » » | 242 | » » » NetworkedPlayerInfo·networkedPlayerInfo·=·GameData.Instance.AllPlayers.Find((NetworkedPlayerInfo·p)·=>·(int)p.PlayerId·==·id); |
| 188 | » » » if·( | 243 | » » » if·(networkedPlayerInfo·!=·null) |
| 189 | » » » { | 244 | » » » { |
| 190 | » » » » settings.Append( | 245 | » » » » settings.Append(networkedPlayerInfo.PlayerName); |
| 191 | » » » } | 246 | » » » } |
| 192 | » » » else | 247 | » » » else |
| 193 | » » » { | 248 | » » » { |
| 194 | » » » » settings.Append(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoundRobin,·Array.Empty<object>())); | 249 | » » » » settings.Append(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoundRobin,·Array.Empty<object>())); |
| 195 | » » » } | 250 | » » » } |
| 196 | » » } | 251 | » » } |
| 197 | » » settings.AppendLine(); | 252 | » » settings.AppendLine(); |
| 198 | » } | 253 | » } |
| 199 | 254 | ||
| 255 | » public·static·StringNames·GetRulesPresetTitle(this·IGameOptions·gameOptions) | ||
| 256 | » { | ||
| 257 | » » RulesPresets·rulesPreset·=·gameOptions.RulesPreset; | ||
| 258 | » » if·(rulesPreset·==·RulesPresets.Standard) | ||
| 259 | » » { | ||
| 260 | » » » return·GameManager.Instance.GameSettingsList.StandardRulesName; | ||
| 261 | » » } | ||
| 262 | » » if·(rulesPreset·!=·RulesPresets.Custom) | ||
| 263 | » » { | ||
| 264 | » » » return·GameManager.Instance.GameSettingsList.AlternateRulesName; | ||
| 265 | » » } | ||
| 266 | » » return·StringNames.GameModeCustom; | ||
| 267 | » } | ||
| 268 | |||
| 200 | » private·const·byte·SkeldBit·=·1; | 269 | » private·const·byte·SkeldBit·=·1; |
| 201 | 270 | ||
| 202 | » private·const·byte·MiraBit·=·2; | 271 | » private·const·byte·MiraBit·=·2; |
| 203 | 272 | ||
| 204 | » private·const·byte·PolusBit·=·4; | 273 | » private·const·byte·PolusBit·=·4; |
| 205 | 274 | ||
| 206 | » private·const·byte·AirshipBit·=·16; | 275 | » private·const·byte·AirshipBit·=·16; |
| Offset 65, 17 lines modified | Offset 65, 17 lines modified | ||
| 65 | » } | 65 | » } |
| 66 | 66 | ||
| 67 | » public·override·bool·DidWin(GameOverReason·gameOverReason) | 67 | » public·override·bool·DidWin(GameOverReason·gameOverReason) |
| 68 | » { | 68 | » { |
| 69 | » » return·GameManager.Instance.DidImpostorsWin(gameOverReason); | 69 | » » return·GameManager.Instance.DidImpostorsWin(gameOverReason); |
| 70 | » } | 70 | » } |
| 71 | 71 | ||
| 72 | » protected·override·bool·IsValidTarget( | 72 | » protected·override·bool·IsValidTarget(NetworkedPlayerInfo·target) |
| 73 | » { | 73 | » { |
| 74 | » » return· | 74 | » » return·base.IsValidTarget(target)·&&·target.Role.CanBeKilled; |
| 75 | » } | 75 | » } |
| 76 | 76 | ||
| 77 | » public·override·PlayerControl·FindClosestTarget() | 77 | » public·override·PlayerControl·FindClosestTarget() |
| 78 | » { | 78 | » { |
| 79 | » » List<PlayerControl>·playersInAbilityRangeSorted·=·base.GetPlayersInAbilityRangeSorted(RoleBehaviour.GetTempPlayerList()); | 79 | » » List<PlayerControl>·playersInAbilityRangeSorted·=·base.GetPlayersInAbilityRangeSorted(RoleBehaviour.GetTempPlayerList()); |
| 80 | » » if·(playersInAbilityRangeSorted.Count·<=·0) | 80 | » » if·(playersInAbilityRangeSorted.Count·<=·0) |
| 81 | » » { | 81 | » » { |
| Offset 267, 27 lines modified | Offset 267, 27 lines modified | ||
| 267 | 267 | ||
| 268 | » [SerializeField] | 268 | » [SerializeField] |
| 269 | » private·PassiveButton·waterBottle; | 269 | » private·PassiveButton·waterBottle; |
| 270 | 270 | ||
| 271 | » [SerializeField] | 271 | » [SerializeField] |
| 272 | » private·GameObject·waterFull; | 272 | » private·GameObject·waterFull; |
| 273 | 273 | ||
| 274 | » [SerializeField] | ||
| 275 | » [Header("Timer")] | 274 | » [Header("Timer")] |
| 275 | » [SerializeField] | ||
| 276 | » private·FungleTimer·timer; | 276 | » private·FungleTimer·timer; |
| 277 | 277 | ||
| 278 | » [SerializeField] | ||
| 279 | » [Header("Glyphs")] | 278 | » [Header("Glyphs")] |
| 279 | » [SerializeField] | ||
| 280 | » private·GameObject·emptyGlyphs; | 280 | » private·GameObject·emptyGlyphs; |
| 281 | 281 | ||
| 282 | » [SerializeField] | 282 | » [SerializeField] |
| 283 | » private·GameObject·hatchedGlyphs; | 283 | » private·GameObject·hatchedGlyphs; |
| 284 | 284 | ||
| 285 | » [SerializeField] | ||
| 286 | » [Header("Audio")] | 285 | » [Header("Audio")] |
| 286 | » [SerializeField] | ||
| 287 | » private·AudioClip·foodPlacedSfx; | 287 | » private·AudioClip·foodPlacedSfx; |
| 288 | 288 | ||
| 289 | » [SerializeField] | 289 | » [SerializeField] |
| 290 | » private·AudioClip·waterPlacedSfx; | 290 | » private·AudioClip·waterPlacedSfx; |
| 291 | 291 | ||
| 292 | » [SerializeField] | 292 | » [SerializeField] |
| 293 | » private·AudioClip·eggPlacedSfx; | 293 | » private·AudioClip·eggPlacedSfx; |
| Offset 183, 16 lines modified | Offset 183, 16 lines modified | ||
| 183 | » » this.buttonPool.ReclaimAll(); | 183 | » » this.buttonPool.ReclaimAll(); |
| 184 | » » for·(int·i·=·0;·i·<·GameData.Instance.AllPlayers.Count;·i++) | 184 | » » for·(int·i·=·0;·i·<·GameData.Instance.AllPlayers.Count;·i++) |
| 185 | » » { | 185 | » » { |
| 186 | » » » PlayerIdentifierButton·component·=·this.buttonPool.Get<PoolableBehavior>().GetComponent<PlayerIdentifierButton>(); | 186 | » » » PlayerIdentifierButton·component·=·this.buttonPool.Get<PoolableBehavior>().GetComponent<PlayerIdentifierButton>(); |
| 187 | » » » Vector3·vector·=·new·Vector3(0f,·-this.buttonHeight·*·(float)i,·0f); | 187 | » » » Vector3·vector·=·new·Vector3(0f,·-this.buttonHeight·*·(float)i,·0f); |
| 188 | » » » component.transform.localPosition·=·vector; | 188 | » » » component.transform.localPosition·=·vector; |
| 189 | » » » component.transform.localScale·=·Vector3.one; | 189 | » » » component.transform.localScale·=·Vector3.one; |
| 190 | » » » | 190 | » » » NetworkedPlayerInfo·networkedPlayerInfo·=·GameData.Instance.AllPlayers[i]; |
| 191 | » » » component.Populate( | 191 | » » » component.Populate(networkedPlayerInfo); |
| 192 | » » » UiElement·componentInChildren·=·component.GetComponentInChildren<UiElement>(true); | 192 | » » » UiElement·componentInChildren·=·component.GetComponentInChildren<UiElement>(true); |
| 193 | » » » this.controllerNavMenu.ControllerSelectable.Add(componentInChildren); | 193 | » » » this.controllerNavMenu.ControllerSelectable.Add(componentInChildren); |
| 194 | » » } | 194 | » » } |
| 195 | » } | 195 | » } |
| 196 | 196 | ||
| 197 | » public·Vector3·offsetFromEdge; | 197 | » public·Vector3·offsetFromEdge; |
| 198 | 198 | ||
| Offset 24, 14 lines modified | Offset 24, 16 lines modified | ||
| 24 | 24 | ||
| 25 | » » public·bool·InScene; | 25 | » » public·bool·InScene; |
| 26 | 26 | ||
| 27 | » » public·bool·IsReady; | 27 | » » public·bool·IsReady; |
| 28 | 28 | ||
| 29 | » » public·bool·HasBeenReported; | 29 | » » public·bool·HasBeenReported; |
| 30 | 30 | ||
| 31 | » » public·bool·IsBeingCreated; | ||
| 32 | |||
| 31 | » » public·PlayerControl·Character; | 33 | » » public·PlayerControl·Character; |
| 32 | 34 | ||
| 33 | » » public·readonly·uint·PlayerLevel·=·1U; | 35 | » » public·readonly·uint·PlayerLevel·=·1U; |
| 34 | 36 | ||
| 35 | » » public·readonly·PlatformSpecificData·PlatformData; | 37 | » » public·readonly·PlatformSpecificData·PlatformData; |
| 36 | 38 | ||
| 37 | » » public·string·PlayerName·=·"???"; | 39 | » » public·string·PlayerName·=·"???"; |
| Offset 203, 33 lines modified | Offset 203, 33 lines modified | ||
| 203 | » » » { | 203 | » » » { |
| 204 | » » » » yield·break; | 204 | » » » » yield·break; |
| 205 | » » » } | 205 | » » » } |
| 206 | » » » ClientData·clientData·=·this.FindClientById(this.ClientId); | 206 | » » » ClientData·clientData·=·this.FindClientById(this.ClientId); |
| 207 | » » » if·(clientData·!=·null) | 207 | » » » if·(clientData·!=·null) |
| 208 | » » » { | 208 | » » » { |
| 209 | » » » » Debug.Log(string.Format("Self·changed·scene:·{0}·{1}",·this.ClientId,·sceneName)); | 209 | » » » » Debug.Log(string.Format("Self·changed·scene:·{0}·{1}",·this.ClientId,·sceneName)); |
| 210 | » » » » if·(this.connection.State·==·ConnectionState.Connected) | ||
| 211 | » » » » { | ||
| 212 | » » » » » MessageWriter·messageWriter·=·MessageWriter.Get(SendOption.Reliable); | ||
| 213 | » » » » » messageWriter.StartMessage(5); | ||
| 214 | » » » » » messageWriter.Write(this.GameId); | ||
| 215 | » » » » » messageWriter.StartMessage(6); | ||
| 216 | » » » » » messageWriter.WritePacked(this.ClientId); | ||
| 217 | » » » » » messageWriter.Write(sceneName); | ||
| 218 | » » » » » messageWriter.EndMessage(); | ||
| 219 | » » » » » messageWriter.EndMessage(); | ||
| 220 | » » » » » this.SendOrDisconnect(messageWriter); | ||
| 221 | » » » » » messageWriter.Recycle(); | ||
| 222 | » » » » } | ||
| 210 | » » » » yield·return·this.CoOnPlayerChangedScene(clientData,·sceneName); | 223 | » » » » yield·return·this.CoOnPlayerChangedScene(clientData,·sceneName); |
| 211 | » » » } | 224 | » » » } |
| 212 | » » » else | 225 | » » » else |
| 213 | » » » { | 226 | » » » { |
| 214 | » » » » Debug.Log(string.Format("Couldn't·find·self·in·clients:·{0}:·",·this.ClientId)·+·sceneName); | 227 | » » » » Debug.Log(string.Format("Couldn't·find·self·in·clients:·{0}:·",·this.ClientId)·+·sceneName); |
| 215 | » » » } | 228 | » » » } |
| 216 | » » » if·(!this.AmHost·&&·this.connection.State·==·ConnectionState.Connected) | ||
| 217 | » » » { | ||
| 218 | » » » » MessageWriter·messageWriter·=·MessageWriter.Get(SendOption.Reliable); | ||
| 219 | » » » » messageWriter.StartMessage(5); | ||
| 220 | » » » » messageWriter.Write(this.GameId); | ||
| 221 | » » » » messageWriter.StartMessage(6); | ||
| 222 | » » » » messageWriter.WritePacked(this.ClientId); | ||
| 223 | » » » » messageWriter.Write(sceneName); | ||
| 224 | » » » » messageWriter.EndMessage(); | ||
| 225 | » » » » messageWriter.EndMessage(); | ||
| 226 | » » » » this.SendOrDisconnect(messageWriter); | ||
| 227 | » » » » messageWriter.Recycle(); | ||
| 228 | » » » } | ||
| 229 | » » » yield·break; | 229 | » » » yield·break; |
| 230 | » » } | 230 | » » } |
| 231 | 231 | ||
| 232 | » » public·void·Spawn(InnerNetObject·netObjParent,·int·ownerId·=·-2,·SpawnFlags·flags·=·SpawnFlags.None) | 232 | » » public·void·Spawn(InnerNetObject·netObjParent,·int·ownerId·=·-2,·SpawnFlags·flags·=·SpawnFlags.None) |
| 233 | » » { | 233 | » » { |
| 234 | » » » if·(this.AmHost) | 234 | » » » if·(this.AmHost) |
| 235 | » » » { | 235 | » » » { |
| Offset 287, 15 lines modified | Offset 287, 15 lines modified | ||
| 287 | » » » messageWriter.EndMessage(); | 287 | » » » messageWriter.EndMessage(); |
| 288 | » » » this.RemoveNetObject(objToDespawn); | 288 | » » » this.RemoveNetObject(objToDespawn); |
| 289 | » » } | 289 | » » } |
| 290 | 290 | ||
| 291 | » » private·bool·AddNetObject(InnerNetObject·obj) | 291 | » » private·bool·AddNetObject(InnerNetObject·obj) |
| 292 | » » { | 292 | » » { |
| 293 | » » » uint·num·=·obj.NetId·+·1U; | 293 | » » » uint·num·=·obj.NetId·+·1U; |
| 294 | » » » if·(num·>·this.NetIdCnt) | 294 | » » » if·(num·>·this.NetIdCnt·&&·num·<·100000U) |
| 295 | » » » { | 295 | » » » { |
| 296 | » » » » this.NetIdCnt·=·num; | 296 | » » » » this.NetIdCnt·=·num; |
| 297 | » » » } | 297 | » » » } |
| 298 | » » » if·(!this.allObjectsFast.ContainsKey(obj.NetId)) | 298 | » » » if·(!this.allObjectsFast.ContainsKey(obj.NetId)) |
| 299 | » » » { | 299 | » » » { |
| 300 | » » » » this.allObjects.Add(obj); | 300 | » » » » this.allObjects.Add(obj); |
| 301 | » » » » this.allObjectsFast.Add(obj.NetId,·obj); | 301 | » » » » this.allObjectsFast.Add(obj.NetId,·obj); |
| Offset 315, 14 lines modified | Offset 315, 15 lines modified | ||
| 315 | » » » obj.NetId·=·uint.MaxValue; | 315 | » » » obj.NetId·=·uint.MaxValue; |
| 316 | » » } | 316 | » » } |
| 317 | 317 | ||
| 318 | » » public·void·RemoveUnownedObjects() | 318 | » » public·void·RemoveUnownedObjects() |
| 319 | » » { | 319 | » » { |
| 320 | » » » HashSet<int>·hashSet·=·new·HashSet<int>(); | 320 | » » » HashSet<int>·hashSet·=·new·HashSet<int>(); |
| 321 | » » » hashSet.Add(-2); | 321 | » » » hashSet.Add(-2); |
| 322 | » » » hashSet.Add(-4); | ||
| 322 | » » » List<ClientData>·list·=·this.allClients; | 323 | » » » List<ClientData>·list·=·this.allClients; |
| 323 | » » » lock·(list) | 324 | » » » lock·(list) |
| 324 | » » » { | 325 | » » » { |
| 325 | » » » » for·(int·i·=·0;·i·<·this.allClients.Count;·i++) | 326 | » » » » for·(int·i·=·0;·i·<·this.allClients.Count;·i++) |
| 326 | » » » » { | 327 | » » » » { |
| 327 | » » » » » ClientData·clientData·=·this.allClients[i]; | 328 | » » » » » ClientData·clientData·=·this.allClients[i]; |
| 328 | » » » » » if·(clientData.Character) | 329 | » » » » » if·(clientData.Character) |
| Offset 786, 15 lines modified | Offset 787, 15 lines modified | ||
| 786 | » » » » » » return·clientData; | 787 | » » » » » » return·clientData; |
| 787 | » » » » » } | 788 | » » » » » } |
| 788 | » » » » } | 789 | » » » » } |
| 789 | » » » } | 790 | » » » } |
| 790 | » » » return·null; | 791 | » » » return·null; |
| 791 | » » } | 792 | » » } |
| 792 | 793 | ||
| 793 | » » public·ClientData·GetClientFromCharacter( | 794 | » » public·ClientData·GetClientFromCharacter(PlayerControl·character) |
| 794 | » » { | 795 | » » { |
| 795 | » » » if·(!character) | 796 | » » » if·(!character) |
| 796 | » » » { | 797 | » » » { |
| 797 | » » » » return·null; | 798 | » » » » return·null; |
| 798 | » » » } | 799 | » » » } |
| 799 | » » » List<ClientData>·list·=·this.allClients; | 800 | » » » List<ClientData>·list·=·this.allClients; |
| 800 | » » » lock·(list) | 801 | » » » lock·(list) |
| Offset 807, 15 lines modified | Offset 808, 36 lines modified | ||
| 807 | » » » » » » return·clientData; | 808 | » » » » » » return·clientData; |
| 808 | » » » » » } | 809 | » » » » » } |
| 809 | » » » » } | 810 | » » » » } |
| 810 | » » » } | 811 | » » » } |
| 811 | » » » return·null; | 812 | » » » return·null; |
| 812 | » » } | 813 | » » } |
| 813 | 814 | ||
| 815 | » » public·ClientData·GetClientFromPlayerInfo(NetworkedPlayerInfo·playerInfo) | ||
| 816 | » » { | ||
| 817 | » » » if·(playerInfo·==·null) | ||
| 818 | » » » { | ||
| 819 | » » » » return·null; | ||
| 820 | » » » } | ||
| 821 | » » » List<ClientData>·list·=·this.allClients; | ||
| 822 | » » » lock·(list) | ||
| 823 | » » » { | ||
| 824 | » » » » for·(int·i·=·0;·i·<·this.allClients.Count;·i++) | ||
| 825 | » » » » { | ||
| 826 | » » » » » ClientData·clientData·=·this.allClients[i]; | ||
| 827 | » » » » » if·(clientData.Id·==·playerInfo.ClientId) | ||
| 828 | » » » » » { | ||
| 829 | » » » » » » return·clientData; | ||
| 830 | » » » » » } | ||
| 831 | » » » » } | ||
| 832 | » » » } | ||
| 833 | » » » return·null; | ||
| 834 | » » } | ||
| 835 | |||
| 814 | » » public·int·GetClientIdFromCharacter( | 836 | » » public·int·GetClientIdFromCharacter(PlayerControl·character) |
| 815 | » » { | 837 | » » { |
| 816 | » » » ClientData·clientFromCharacter·=·this.GetClientFromCharacter(character); | 838 | » » » ClientData·clientFromCharacter·=·this.GetClientFromCharacter(character); |
| 817 | » » » if·(clientFromCharacter·==·null) | 839 | » » » if·(clientFromCharacter·==·null) |
| Max diff block lines reached; 15259/18945 bytes (80.54%) of diff not shown. | |||
| Offset 44, 10 lines modified | Offset 44, 12 lines modified | ||
| 44 | 44 | ||
| 45 | » » public·const·byte·SetActivePodType·=·21; | 45 | » » public·const·byte·SetActivePodType·=·21; |
| 46 | 46 | ||
| 47 | » » public·const·byte·QueryPlatformIds·=·22; | 47 | » » public·const·byte·QueryPlatformIds·=·22; |
| 48 | 48 | ||
| 49 | » » public·const·byte·QueryLobbyInfo·=·23; | 49 | » » public·const·byte·QueryLobbyInfo·=·23; |
| 50 | 50 | ||
| 51 | » » public·const·byte·EndGameHostMigration·=·24; | ||
| 52 | |||
| 51 | » » public·const·byte·ServerDebugAlert·=·255; | 53 | » » public·const·byte·ServerDebugAlert·=·255; |
| 52 | » } | 54 | » } |
| 53 | } | 55 | } |
| Offset 72, 15 lines modified | Offset 72, 18 lines modified | ||
| 72 | » » » » return; | 72 | » » » » return; |
| 73 | » » » } | 73 | » » » } |
| 74 | » » » addressableAsset.Unload(); | 74 | » » » addressableAsset.Unload(); |
| 75 | » » } | 75 | » » } |
| 76 | 76 | ||
| 77 | » » private·void·OnAssetLoaded() | 77 | » » private·void·OnAssetLoaded() |
| 78 | » » { | 78 | » » { |
| 79 | » » » if·(this.spriteRenderer·!=·null) | ||
| 80 | » » » { | ||
| 79 | » » » this.spriteRenderer.sprite·=·this.asset.GetAsset(); | 81 | » » » » this.spriteRenderer.sprite·=·this.asset.GetAsset(); |
| 82 | » » » } | ||
| 80 | » » } | 83 | » » } |
| 81 | 84 | ||
| 82 | » » public·bool·unloadOnDisable·=·true; | 85 | » » public·bool·unloadOnDisable·=·true; |
| 83 | 86 | ||
| 84 | » » private·AddressableAsset<Sprite>·asset; | 87 | » » private·AddressableAsset<Sprite>·asset; |
| 85 | 88 | ||
| 86 | » » private·SpriteRenderer·spriteRenderer; | 89 | » » private·SpriteRenderer·spriteRenderer; |
| Offset 553, 16 lines modified | Offset 553, 16 lines modified | ||
| 553 | 553 | ||
| 554 | » » [SerializeField] | 554 | » » [SerializeField] |
| 555 | » » private·Transform·commandButtonParent; | 555 | » » private·Transform·commandButtonParent; |
| 556 | 556 | ||
| 557 | » » [SerializeField] | 557 | » » [SerializeField] |
| 558 | » » private·ScrollRect·commandScrollList; | 558 | » » private·ScrollRect·commandScrollList; |
| 559 | 559 | ||
| 560 | » » [SerializeField] | ||
| 561 | » » [Header("Details")] | 560 | » » [Header("Details")] |
| 561 | » » [SerializeField] | ||
| 562 | » » private·GameObject·detailsParent; | 562 | » » private·GameObject·detailsParent; |
| 563 | 563 | ||
| 564 | » » [SerializeField] | 564 | » » [SerializeField] |
| 565 | » » private·TextMeshProUGUI·basePath; | 565 | » » private·TextMeshProUGUI·basePath; |
| 566 | 566 | ||
| 567 | » » [SerializeField] | 567 | » » [SerializeField] |
| 568 | » » private·TextMeshProUGUI·commandName; | 568 | » » private·TextMeshProUGUI·commandName; |
| Offset 86, 25 lines modified | Offset 86, 25 lines modified | ||
| 86 | » » » » if·(debugToolInputProvider.GetToggle()) | 86 | » » » » if·(debugToolInputProvider.GetToggle()) |
| 87 | » » » » { | 87 | » » » » { |
| 88 | » » » » » this.ToggleUIVisible(!this.UIVisible); | 88 | » » » » » this.ToggleUIVisible(!this.UIVisible); |
| 89 | » » » » » break; | 89 | » » » » » break; |
| 90 | » » » » } | 90 | » » » » } |
| 91 | » » » » if·(this.UIVisible·&&·!this.SubpageConsumingNavActions) | 91 | » » » » if·(this.UIVisible·&&·!this.SubpageConsumingNavActions) |
| 92 | » » » » { | 92 | » » » » { |
| 93 | » » » » » if·(debugToolInputProvider.Get | 93 | » » » » » if·(debugToolInputProvider.GetPagePrevious()) |
| 94 | » » » » » { | 94 | » » » » » { |
| 95 | » » » » » » this.activeTabIndex--; | 95 | » » » » » » this.activeTabIndex--; |
| 96 | » » » » » » if·(this.activeTabIndex·<·0) | 96 | » » » » » » if·(this.activeTabIndex·<·0) |
| 97 | » » » » » » { | 97 | » » » » » » { |
| 98 | » » » » » » » this.activeTabIndex·=·this.totalTabs·-·1; | 98 | » » » » » » » this.activeTabIndex·=·this.totalTabs·-·1; |
| 99 | » » » » » » } | 99 | » » » » » » } |
| 100 | » » » » » » this.ShowPage(this.tabButtons[this.activeTabIndex].PageName); | 100 | » » » » » » this.ShowPage(this.tabButtons[this.activeTabIndex].PageName); |
| 101 | » » » » » » break; | 101 | » » » » » » break; |
| 102 | » » » » » } | 102 | » » » » » } |
| 103 | » » » » » if·(debugToolInputProvider.Get | 103 | » » » » » if·(debugToolInputProvider.GetPageNext()) |
| 104 | » » » » » { | 104 | » » » » » { |
| 105 | » » » » » » this.activeTabIndex++; | 105 | » » » » » » this.activeTabIndex++; |
| 106 | » » » » » » if·(this.activeTabIndex·>=·this.totalTabs) | 106 | » » » » » » if·(this.activeTabIndex·>=·this.totalTabs) |
| 107 | » » » » » » { | 107 | » » » » » » { |
| 108 | » » » » » » » this.activeTabIndex·=·0; | 108 | » » » » » » » this.activeTabIndex·=·0; |
| 109 | » » » » » » } | 109 | » » » » » » } |
| 110 | » » » » » » this.ShowPage(this.tabButtons[this.activeTabIndex].PageName); | 110 | » » » » » » this.ShowPage(this.tabButtons[this.activeTabIndex].PageName); |
| Offset 12, 14 lines modified | Offset 12, 19 lines modified | ||
| 12 | » » » this.tapButton.onClick.AddListener(new·UnityAction(this.Tap)); | 12 | » » » this.tapButton.onClick.AddListener(new·UnityAction(this.Tap)); |
| 13 | » » » this.debugOverlay.AddToggleActiveCallback(delegate(bool·visible) | 13 | » » » this.debugOverlay.AddToggleActiveCallback(delegate(bool·visible) |
| 14 | » » » { | 14 | » » » { |
| 15 | » » » » this.tapButton.gameObject.SetActive(!visible); | 15 | » » » » this.tapButton.gameObject.SetActive(!visible); |
| 16 | » » » }); | 16 | » » » }); |
| 17 | » » } | 17 | » » } |
| 18 | 18 | ||
| 19 | » » public·void·SetRaycastTarget(bool·raycast) | ||
| 20 | » » { | ||
| 21 | » » » this.tapButton.GetComponent<Image>().raycastTarget·=·raycast; | ||
| 22 | » » } | ||
| 23 | |||
| 19 | » » private·void·Tap() | 24 | » » private·void·Tap() |
| 20 | » » { | 25 | » » { |
| 21 | » » » float·time·=·Time.time; | 26 | » » » float·time·=·Time.time; |
| 22 | » » » if·(this.numTapsSoFar·>·0·&&·time·-·this.lastTapTime·<=·this.maxSecondsBetweenTaps) | 27 | » » » if·(this.numTapsSoFar·>·0·&&·time·-·this.lastTapTime·<=·this.maxSecondsBetweenTaps) |
| 23 | » » » { | 28 | » » » { |
| 24 | » » » » this.numTapsSoFar++; | 29 | » » » » this.numTapsSoFar++; |
| 25 | » » » } | 30 | » » » } |
| Offset 15, 12 lines modified | Offset 15, 16 lines modified | ||
| 15 | 15 | ||
| 16 | » » bool·GetClear(); | 16 | » » bool·GetClear(); |
| 17 | 17 | ||
| 18 | » » bool·GetConfirm(); | 18 | » » bool·GetConfirm(); |
| 19 | 19 | ||
| 20 | » » bool·GetCancel(); | 20 | » » bool·GetCancel(); |
| 21 | 21 | ||
| 22 | » » bool·GetPagePrevious(); | ||
| 23 | |||
| 24 | » » bool·GetPageNext(); | ||
| 25 | |||
| 22 | » » bool·GetNavLeft(); | 26 | » » bool·GetNavLeft(); |
| 23 | 27 | ||
| 24 | » » bool·GetNavRight(); | 28 | » » bool·GetNavRight(); |
| 25 | » } | 29 | » } |
| 26 | } | 30 | } |
| Offset 17, 15 lines modified | Offset 17, 15 lines modified | ||
| 17 | » » » global::Logger.GlobalInstance.Info("IntroCutscene·::·CoBegin()·::·Game·Mode:·Normal",·null); | 17 | » » » global::Logger.GlobalInstance.Info("IntroCutscene·::·CoBegin()·::·Game·Mode:·Normal",·null); |
| 18 | » » » this.LogPlayerRoleData(); | 18 | » » » this.LogPlayerRoleData(); |
| 19 | » » » this.HideAndSeekPanels.SetActive(false); | 19 | » » » this.HideAndSeekPanels.SetActive(false); |
| 20 | » » » this.CrewmateRules.SetActive(false); | 20 | » » » this.CrewmateRules.SetActive(false); |
| 21 | » » » this.ImpostorRules.SetActive(false); | 21 | » » » this.ImpostorRules.SetActive(false); |
| 22 | » » » this.ImpostorName.gameObject.SetActive(false); | 22 | » » » this.ImpostorName.gameObject.SetActive(false); |
| 23 | » » » this.ImpostorTitle.gameObject.SetActive(false); | 23 | » » » this.ImpostorTitle.gameObject.SetActive(false); |
| 24 | » » » List<PlayerControl>·list·=·IntroCutscene.SelectTeamToShow(( | 24 | » » » List<PlayerControl>·list·=·IntroCutscene.SelectTeamToShow((NetworkedPlayerInfo·pcd)·=>·!PlayerControl.LocalPlayer.Data.Role.IsImpostor·||·pcd.Role.TeamType·==·PlayerControl.LocalPlayer.Data.Role.TeamType); |
| 25 | » » » if·(list·==·null·||·list.Count·<·1) | 25 | » » » if·(list·==·null·||·list.Count·<·1) |
| 26 | » » » { | 26 | » » » { |
| 27 | » » » » global::Logger.GlobalInstance.Error("IntroCutscene·::·CoBegin()·::·teamToShow·is·EMPTY·or·NULL",·null); | 27 | » » » » global::Logger.GlobalInstance.Error("IntroCutscene·::·CoBegin()·::·teamToShow·is·EMPTY·or·NULL",·null); |
| 28 | » » » } | 28 | » » » } |
| 29 | » » » if·(PlayerControl.LocalPlayer.Data.Role.IsImpostor) | 29 | » » » if·(PlayerControl.LocalPlayer.Data.Role.IsImpostor) |
| 30 | » » » { | 30 | » » » { |
| 31 | » » » » this.ImpostorText.gameObject.SetActive(false); | 31 | » » » » this.ImpostorText.gameObject.SetActive(false); |
| Offset 58, 15 lines modified | Offset 58, 15 lines modified | ||
| 58 | » » » » this.ImpostorRules.SetActive(true); | 58 | » » » » this.ImpostorRules.SetActive(true); |
| 59 | » » » } | 59 | » » » } |
| 60 | » » » else | 60 | » » » else |
| 61 | » » » { | 61 | » » » { |
| 62 | » » » » this.CrewmateRules.SetActive(true); | 62 | » » » » this.CrewmateRules.SetActive(true); |
| 63 | » » » » this.ImpostorRules.SetActive(false); | 63 | » » » » this.ImpostorRules.SetActive(false); |
| 64 | » » » } | 64 | » » » } |
| 65 | » » » List<PlayerControl>·list2·=·IntroCutscene.SelectTeamToShow(( | 65 | » » » List<PlayerControl>·list2·=·IntroCutscene.SelectTeamToShow((NetworkedPlayerInfo·pcd)·=>·PlayerControl.LocalPlayer.Data.Role.IsImpostor·!=·pcd.Role.IsImpostor); |
| 66 | » » » if·(list2·==·null·||·list2.Count·<·1) | 66 | » » » if·(list2·==·null·||·list2.Count·<·1) |
| 67 | » » » { | 67 | » » » { |
| 68 | » » » » global::Logger.GlobalInstance.Error("IntroCutscene·::·CoBegin()·::·teamToShow·is·EMPTY·or·NULL",·null); | 68 | » » » » global::Logger.GlobalInstance.Error("IntroCutscene·::·CoBegin()·::·teamToShow·is·EMPTY·or·NULL",·null); |
| 69 | » » » } | 69 | » » » } |
| 70 | » » » PlayerControl·impostor·=·PlayerControl.AllPlayerControls.Find((PlayerControl·pc)·=>·pc.Data.Role.IsImpostor); | 70 | » » » PlayerControl·impostor·=·PlayerControl.AllPlayerControls.Find((PlayerControl·pc)·=>·pc.Data.Role.IsImpostor); |
| 71 | » » » if·(impostor·==·null) | 71 | » » » if·(impostor·==·null) |
| 72 | » » » { | 72 | » » » { |
| Offset 188, 17 lines modified | Offset 188, 17 lines modified | ||
| 188 | » » if·(this.HideAndSeekPlayerVisual.HasHat()) | 188 | » » if·(this.HideAndSeekPlayerVisual.HasHat()) |
| 189 | » » { | 189 | » » { |
| 190 | » » » this.HideAndSeekPlayerVisual.GetHandHat().gameObject.SetActive(true); | 190 | » » » this.HideAndSeekPlayerVisual.GetHandHat().gameObject.SetActive(true); |
| 191 | » » » this.HideAndSeekPlayerVisual.ToggleHat(true); | 191 | » » » this.HideAndSeekPlayerVisual.ToggleHat(true); |
| 192 | » » } | 192 | » » } |
| 193 | » } | 193 | » } |
| 194 | 194 | ||
| 195 | » private·static·List<PlayerControl>·SelectTeamToShow(Func< | 195 | » private·static·List<PlayerControl>·SelectTeamToShow(Func<NetworkedPlayerInfo,·bool>·roleFilter) |
| 196 | » { | 196 | » { |
| 197 | » » return·Enumerable.ToList<PlayerControl>(Enumerable.OrderBy<PlayerControl,·int>(Enumerable.Select< | 197 | » » return·Enumerable.ToList<PlayerControl>(Enumerable.OrderBy<PlayerControl,·int>(Enumerable.Select<NetworkedPlayerInfo,·PlayerControl>(Enumerable.Where<NetworkedPlayerInfo>(GameData.Instance.AllPlayers,·(NetworkedPlayerInfo·pcd)·=>·!pcd.Disconnected·&&·roleFilter(pcd)),·(NetworkedPlayerInfo·pcd)·=>·pcd.Object),·delegate(PlayerControl·pc) |
| 198 | » » { | 198 | » » { |
| 199 | » » » if·(!(pc·==·PlayerControl.LocalPlayer)) | 199 | » » » if·(!(pc·==·PlayerControl.LocalPlayer)) |
| 200 | » » » { | 200 | » » » { |
| 201 | » » » » return·1; | 201 | » » » » return·1; |
| 202 | » » » } | 202 | » » » } |
| 203 | » » » return·0; | 203 | » » » return·0; |
| 204 | » » })); | 204 | » » })); |
| Offset 266, 16 lines modified | Offset 266, 16 lines modified | ||
| 266 | » » this.TeamTitle.color·=·Palette.CrewmateBlue; | 266 | » » this.TeamTitle.color·=·Palette.CrewmateBlue; |
| 267 | » » int·num·=·Mathf.CeilToInt(7.5f); | 267 | » » int·num·=·Mathf.CeilToInt(7.5f); |
| 268 | » » for·(int·i·=·0;·i·<·teamToDisplay.Count;·i++) | 268 | » » for·(int·i·=·0;·i·<·teamToDisplay.Count;·i++) |
| 269 | » » { | 269 | » » { |
| 270 | » » » PlayerControl·playerControl·=·teamToDisplay[i]; | 270 | » » » PlayerControl·playerControl·=·teamToDisplay[i]; |
| 271 | » » » if·(playerControl) | 271 | » » » if·(playerControl) |
| 272 | » » » { | 272 | » » » { |
| 273 | » » » » | 273 | » » » » NetworkedPlayerInfo·data·=·playerControl.Data; |
| 274 | » » » » if·(data· | 274 | » » » » if·(!(data·==·null)) |
| 275 | » » » » { | 275 | » » » » { |
| 276 | » » » » » PoolablePlayer·poolablePlayer·=·this.CreatePlayer(i,·num,·data,·false); | 276 | » » » » » PoolablePlayer·poolablePlayer·=·this.CreatePlayer(i,·num,·data,·false); |
| 277 | » » » » » if·(i·==·0·&&·data.PlayerId·==·PlayerControl.LocalPlayer.PlayerId) | 277 | » » » » » if·(i·==·0·&&·data.PlayerId·==·PlayerControl.LocalPlayer.PlayerId) |
| 278 | » » » » » { | 278 | » » » » » { |
| 279 | » » » » » » this.ourCrewmate·=·poolablePlayer; | 279 | » » » » » » this.ourCrewmate·=·poolablePlayer; |
| 280 | » » » » » } | 280 | » » » » » } |
| 281 | » » » » } | 281 | » » » » } |
| Offset 288, 16 lines modified | Offset 288, 16 lines modified | ||
| 288 | » » this.TeamTitle.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Impostor,·Array.Empty<object>()); | 288 | » » this.TeamTitle.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Impostor,·Array.Empty<object>()); |
| 289 | » » this.TeamTitle.color·=·Palette.ImpostorRed; | 289 | » » this.TeamTitle.color·=·Palette.ImpostorRed; |
| 290 | » » for·(int·i·=·0;·i·<·yourTeam.Count;·i++) | 290 | » » for·(int·i·=·0;·i·<·yourTeam.Count;·i++) |
| 291 | » » { | 291 | » » { |
| 292 | » » » PlayerControl·playerControl·=·yourTeam[i]; | 292 | » » » PlayerControl·playerControl·=·yourTeam[i]; |
| 293 | » » » if·(playerControl) | 293 | » » » if·(playerControl) |
| 294 | » » » { | 294 | » » » { |
| 295 | » » » » | 295 | » » » » NetworkedPlayerInfo·data·=·playerControl.Data; |
| 296 | » » » » if·(data· | 296 | » » » » if·(!(data·==·null)) |
| 297 | » » » » { | 297 | » » » » { |
| 298 | » » » » » PoolablePlayer·poolablePlayer·=·this.CreatePlayer(i,·1,·data,·true); | 298 | » » » » » PoolablePlayer·poolablePlayer·=·this.CreatePlayer(i,·1,·data,·true); |
| 299 | » » » » » if·(i·==·0·&&·data.PlayerId·==·PlayerControl.LocalPlayer.PlayerId) | 299 | » » » » » if·(i·==·0·&&·data.PlayerId·==·PlayerControl.LocalPlayer.PlayerId) |
| 300 | » » » » » { | 300 | » » » » » { |
| 301 | » » » » » » this.ourCrewmate·=·poolablePlayer; | 301 | » » » » » » this.ourCrewmate·=·poolablePlayer; |
| 302 | » » » » » } | 302 | » » » » » } |
| 303 | » » » » } | 303 | » » » » } |
| Offset 339, 15 lines modified | Offset 339, 15 lines modified | ||
| 339 | » » if·(this.overlayHandle·!=·null) | 339 | » » if·(this.overlayHandle·!=·null) |
| 340 | » » { | 340 | » » { |
| 341 | » » » this.overlayHandle.Dispose(); | 341 | » » » this.overlayHandle.Dispose(); |
| 342 | » » » this.overlayHandle·=·null; | 342 | » » » this.overlayHandle·=·null; |
| 343 | » » } | 343 | » » } |
| 344 | » } | 344 | » } |
| 345 | 345 | ||
| 346 | » private·PoolablePlayer·CreatePlayer(int·i,·int·maxDepth,· | 346 | » private·PoolablePlayer·CreatePlayer(int·i,·int·maxDepth,·NetworkedPlayerInfo·pData,·bool·impostorPositioning) |
| 347 | » { | 347 | » { |
| 348 | » » int·num·=·((i·%·2·==·0)·?·(-1)·:·1); | 348 | » » int·num·=·((i·%·2·==·0)·?·(-1)·:·1); |
| 349 | » » int·num2·=·(i·+·1)·/·2; | 349 | » » int·num2·=·(i·+·1)·/·2; |
| 350 | » » float·num3·=·(float)((i·==·0)·?·(-8)·:·(-1)); | 350 | » » float·num3·=·(float)((i·==·0)·?·(-8)·:·(-1)); |
| 351 | » » PoolablePlayer·poolablePlayer·=·Object.Instantiate<PoolablePlayer>(this.PlayerPrefab,·base.transform); | 351 | » » PoolablePlayer·poolablePlayer·=·Object.Instantiate<PoolablePlayer>(this.PlayerPrefab,·base.transform); |
| 352 | » » poolablePlayer.name·=·pData.PlayerName·+·"Dummy"; | 352 | » » poolablePlayer.name·=·pData.PlayerName·+·"Dummy"; |
| 353 | » » poolablePlayer.SetFlipX(i·%·2·==·0); | 353 | » » poolablePlayer.SetFlipX(i·%·2·==·0); |
| Offset 6, 11 lines modified | Offset 6, 11 lines modified | ||
| 6 | 6 | ||
| 7 | » float·PercentCool·{·get;·} | 7 | » float·PercentCool·{·get;·} |
| 8 | 8 | ||
| 9 | » ImageNames·UseIcon·{·get;·} | 9 | » ImageNames·UseIcon·{·get;·} |
| 10 | 10 | ||
| 11 | » void·SetOutline(bool·on,·bool·mainTarget); | 11 | » void·SetOutline(bool·on,·bool·mainTarget); |
| 12 | 12 | ||
| 13 | » float·CanUse( | 13 | » float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse); |
| 14 | 14 | ||
| 15 | » void·Use(); | 15 | » void·Use(); |
| 16 | } | 16 | } |
| Offset 45, 14 lines modified | Offset 45, 24 lines modified | ||
| 45 | » } | 45 | » } |
| 46 | 46 | ||
| 47 | » public·bool·GetCancel() | 47 | » public·bool·GetCancel() |
| 48 | » { | 48 | » { |
| 49 | » » return·Input.GetKeyUp(KeyCode.Escape); | 49 | » » return·Input.GetKeyUp(KeyCode.Escape); |
| 50 | » } | 50 | » } |
| 51 | 51 | ||
| 52 | » public·bool·GetPagePrevious() | ||
| 53 | » { | ||
| 54 | » » return·Input.GetKey(KeyCode.Q); | ||
| 55 | » } | ||
| 56 | |||
| 57 | » public·bool·GetPageNext() | ||
| 58 | » { | ||
| 59 | » » return·Input.GetKey(KeyCode.E); | ||
| 60 | » } | ||
| 61 | |||
| 52 | » public·bool·GetNavLeft() | 62 | » public·bool·GetNavLeft() |
| 53 | » { | 63 | » { |
| 54 | » » return·Input.GetKey(KeyCode.LeftShift)·&&·Input.GetKeyUp(KeyCode.Tab); | 64 | » » return·Input.GetKey(KeyCode.LeftShift)·&&·Input.GetKeyUp(KeyCode.Tab); |
| 55 | » } | 65 | » } |
| 56 | 66 | ||
| 57 | » public·bool·GetNavRight() | 67 | » public·bool·GetNavRight() |
| 58 | » { | 68 | » { |
| Offset 3, 9 lines modified | Offset 3, 10 lines modified | ||
| 3 | public·enum·KillAnimType | 3 | public·enum·KillAnimType |
| 4 | { | 4 | { |
| 5 | » Stab, | 5 | » Stab, |
| 6 | » Tongue, | 6 | » Tongue, |
| 7 | » Shoot, | 7 | » Shoot, |
| 8 | » Neck, | 8 | » Neck, |
| 9 | » RHM, | 9 | » RHM, |
| 10 | » Werewolf_Slash, | ||
| 10 | » None·=·9999 | 11 | » None·=·9999 |
| 11 | } | 12 | } |
| Offset 1, 12 lines modified | Offset 1, 20 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections.Generic; | 2 | using·System.Collections.Generic; |
| 3 | 3 | ||
| 4 | public·class·KillButton·:·ActionButton | 4 | public·class·KillButton·:·ActionButton |
| 5 | { | 5 | { |
| 6 | » public·PlayerControl·Target | ||
| 7 | » { | ||
| 8 | » » get | ||
| 9 | » » { | ||
| 10 | » » » return·this.currentTarget; | ||
| 11 | » » } | ||
| 12 | » } | ||
| 13 | |||
| 6 | » public·override·void·DoClick() | 14 | » public·override·void·DoClick() |
| 7 | » { | 15 | » { |
| 8 | » » if·(base.isActiveAndEnabled·&&·this.currentTarget·&&·!this.isCoolingDown·&&·!PlayerControl.LocalPlayer.Data.IsDead·&&·PlayerControl.LocalPlayer.CanMove) | 16 | » » if·(base.isActiveAndEnabled·&&·this.currentTarget·&&·!this.isCoolingDown·&&·!PlayerControl.LocalPlayer.Data.IsDead·&&·PlayerControl.LocalPlayer.CanMove) |
| 9 | » » { | 17 | » » { |
| 10 | » » » PlayerControl.LocalPlayer.CmdCheckMurder(this.currentTarget); | 18 | » » » PlayerControl.LocalPlayer.CmdCheckMurder(this.currentTarget); |
| 11 | » » » this.SetTarget(null); | 19 | » » » this.SetTarget(null); |
| 12 | » » } | 20 | » » } |
| Offset 19, 32 lines modified | Offset 19, 18 lines modified | ||
| 19 | » » while·(this.showAll·!=·null·||·this.queue.Count·>·0) | 19 | » » while·(this.showAll·!=·null·||·this.queue.Count·>·0) |
| 20 | » » { | 20 | » » { |
| 21 | » » » yield·return·null; | 21 | » » » yield·return·null; |
| 22 | » » } | 22 | » » } |
| 23 | » » yield·break; | 23 | » » yield·break; |
| 24 | » } | 24 | » } |
| 25 | 25 | ||
| 26 | » public·void·ShowKillAnimation(OverlayKillAnimation·killAnimation,·GameData.PlayerInfo·killer,·GameData.PlayerInfo·victim) | ||
| 27 | » { | ||
| 28 | » » this.queue.Enqueue(delegate | ||
| 29 | » » { | ||
| 30 | » » » OverlayKillAnimation·overlayKillAnimation·=·Object.Instantiate<OverlayKillAnimation>(killAnimation,·this.transform); | ||
| 31 | » » » overlayKillAnimation.Initialize(killer,·victim); | ||
| 32 | » » » overlayKillAnimation.gameObject.SetActive(false); | ||
| 33 | » » » return·this.CoShowOne(overlayKillAnimation); | ||
| 34 | » » }); | ||
| 35 | » » if·(this.showAll·==·null) | ||
| 36 | » » { | ||
| 37 | » » » this.showAll·=·base.StartCoroutine(this.ShowAll()); | ||
| 38 | » » } | ||
| 39 | » } | ||
| 40 | |||
| 41 | » public·void·ShowKillAnimation( | 26 | » public·void·ShowKillAnimation(NetworkedPlayerInfo·killer,·NetworkedPlayerInfo·victim) |
| 42 | » { | 27 | » { |
| 43 | » » IEnumerable<OverlayKillAnimation>·enumerable·=·this.KillAnims; | 28 | » » IEnumerable<OverlayKillAnimation>·enumerable·=·this.KillAnims; |
| 29 | » » OverlayKillAnimation·overlayKillAnimation; | ||
| 44 | » » if·(killer.Object) | 30 | » » if·(killer.Object) |
| 45 | » » { | 31 | » » { |
| 46 | » » » OverlayKillAnimation[]·killAnimations·=·killer.Object.MyPhysics.Animations.GetKillAnimations(); | 32 | » » » OverlayKillAnimation[]·killAnimations·=·killer.Object.MyPhysics.Animations.GetKillAnimations(); |
| 47 | » » » if·(GameOptionsManager.Instance.CurrentGameOptions.GameMode·==·GameModes.HideNSeek·&&·AprilFoolsMode.ShouldHorseAround()) | 33 | » » » if·(GameOptionsManager.Instance.CurrentGameOptions.GameMode·==·GameModes.HideNSeek·&&·AprilFoolsMode.ShouldHorseAround()) |
| 48 | » » » { | 34 | » » » { |
| 49 | » » » » enumerable·=·this.HorseWrangleAnims; | 35 | » » » » enumerable·=·this.HorseWrangleAnims; |
| 50 | » » » } | 36 | » » » } |
| Offset 53, 28 lines modified | Offset 39, 60 lines modified | ||
| 53 | » » » » enumerable·=·killAnimations; | 39 | » » » » enumerable·=·killAnimations; |
| 54 | » » » } | 40 | » » » } |
| 55 | » » » else | 41 | » » » else |
| 56 | » » » { | 42 | » » » { |
| 57 | » » » » SkinViewData·skin·=·ShipStatus.Instance.CosmeticsCache.GetSkin(killer.Object.CurrentOutfit.SkinId); | 43 | » » » » SkinViewData·skin·=·ShipStatus.Instance.CosmeticsCache.GetSkin(killer.Object.CurrentOutfit.SkinId); |
| 58 | » » » » if·(skin·&&·skin.CustomKillAnimID·>·0) | 44 | » » » » if·(skin·&&·skin.CustomKillAnimID·>·0) |
| 59 | » » » » { | 45 | » » » » { |
| 46 | » » » » » if·(!string.IsNullOrEmpty(skin.HatID_KillAnim)·&&·skin.HatID_KillAnim·!=·killer.Object.CurrentOutfit.HatId) | ||
| 47 | » » » » » { | ||
| 48 | » » » » » » overlayKillAnimation·=·enumerable.Random<OverlayKillAnimation>(); | ||
| 49 | » » » » » » this.ShowKillAnimation(overlayKillAnimation,·killer,·victim); | ||
| 50 | » » » » » » return; | ||
| 51 | » » » » » } | ||
| 52 | » » » » » if·(!string.IsNullOrEmpty(skin.VisorID_KillAnim)·&&·skin.VisorID_KillAnim·!=·killer.Object.CurrentOutfit.VisorId) | ||
| 53 | » » » » » { | ||
| 54 | » » » » » » overlayKillAnimation·=·enumerable.Random<OverlayKillAnimation>(); | ||
| 55 | » » » » » » this.ShowKillAnimation(overlayKillAnimation,·killer,·victim); | ||
| 56 | » » » » » » return; | ||
| 57 | » » » » » } | ||
| 60 | » » » » » enumerable·=·new·OverlayKillAnimation[]·{·this.CustomKillAnimations[skin.CustomKillAnimID·-·1]·}; | 58 | » » » » » enumerable·=·new·OverlayKillAnimation[]·{·this.CustomKillAnimations[skin.CustomKillAnimID·-·1]·}; |
| 61 | » » » » } | 59 | » » » » } |
| 62 | » » » } | 60 | » » » } |
| 63 | » » } | 61 | » » } |
| 64 | » » | 62 | » » overlayKillAnimation·=·enumerable.Random<OverlayKillAnimation>(); |
| 65 | » » this.ShowKillAnimation(overlayKillAnimation,·killer,·victim); | 63 | » » this.ShowKillAnimation(overlayKillAnimation,·killer,·victim); |
| 66 | » } | 64 | » } |
| 67 | 65 | ||
| 66 | » public·void·ShowKillAnimation(OverlayKillAnimation·killAnimation,·NetworkedPlayerInfo·killer,·NetworkedPlayerInfo·victim) | ||
| 67 | » { | ||
| 68 | » » this.ShowKillAnimation(killAnimation,·new·KillOverlayInitData(killer,·victim)); | ||
| 69 | » } | ||
| 70 | |||
| 71 | » public·void·ShowKillAnimation(OverlayKillAnimation·killAnimation,·KillOverlayInitData·initData) | ||
| 72 | » { | ||
| 73 | » » this.queue.Enqueue(delegate | ||
| 74 | » » { | ||
| 75 | » » » OverlayKillAnimation·overlayKillAnimation·=·Object.Instantiate<OverlayKillAnimation>(killAnimation,·this.transform); | ||
| 76 | » » » overlayKillAnimation.Initialize(initData); | ||
| 77 | » » » overlayKillAnimation.gameObject.SetActive(false); | ||
| 78 | » » » return·this.CoShowOne(overlayKillAnimation); | ||
| 79 | » » }); | ||
| 80 | » » if·(this.showAll·==·null) | ||
| 81 | » » { | ||
| 82 | » » » this.showAll·=·base.StartCoroutine(this.ShowAll()); | ||
| 83 | » » } | ||
| 84 | » } | ||
| 85 | |||
| 68 | » public·void·ShowMeeting(MeetingCalledAnimation·prefab,· | 86 | » public·void·ShowMeeting(MeetingCalledAnimation·prefab,·NetworkedPlayerInfo.PlayerOutfit·playerOutfit) |
| 69 | » { | 87 | » { |
| 70 | » » this.queue.Enqueue(delegate | 88 | » » this.queue.Enqueue(delegate |
| 71 | » » { | 89 | » » { |
| 72 | » » » MeetingCalledAnimation·meetingCalledAnimation·=·Object.Instantiate<MeetingCalledAnimation>(prefab,·this.transform); | 90 | » » » MeetingCalledAnimation·meetingCalledAnimation·=·Object.Instantiate<MeetingCalledAnimation>(prefab,·this.transform); |
| 73 | » » » meetingCalledAnimation.Initialize(player | 91 | » » » meetingCalledAnimation.Initialize(playerOutfit); |
| 74 | » » » meetingCalledAnimation.gameObject.SetActive(false); | 92 | » » » meetingCalledAnimation.gameObject.SetActive(false); |
| 75 | » » » return·this.CoShowOne(meetingCalledAnimation); | 93 | » » » return·this.CoShowOne(meetingCalledAnimation); |
| 76 | » » }); | 94 | » » }); |
| 77 | » » if·(this.showAll·==·null) | 95 | » » if·(this.showAll·==·null) |
| 78 | » » { | 96 | » » { |
| 79 | » » » this.showAll·=·base.StartCoroutine(this.ShowAll()); | 97 | » » » this.showAll·=·base.StartCoroutine(this.ShowAll()); |
| 80 | » » } | 98 | » » } |
| Offset 43, 19 lines modified | Offset 43, 19 lines modified | ||
| 43 | » } | 43 | » } |
| 44 | 44 | ||
| 45 | » private·void·Update() | 45 | » private·void·Update() |
| 46 | » { | 46 | » { |
| 47 | » » this.CoolDown·=·Mathf.Max(this.CoolDown·-·Time.deltaTime,·0f); | 47 | » » this.CoolDown·=·Mathf.Max(this.CoolDown·-·Time.deltaTime,·0f); |
| 48 | » } | 48 | » } |
| 49 | 49 | ||
| 50 | » public·float·CanUse( | 50 | » public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse) |
| 51 | » { | 51 | » { |
| 52 | » » float·num·=·float.MaxValue; | 52 | » » float·num·=·float.MaxValue; |
| 53 | » » PlayerControl·@object·=·pc.Object; | 53 | » » PlayerControl·@object·=·pc.Object; |
| 54 | » » couldUse·=·!pc.IsDead·&&·@object.CanMove; | 54 | » » couldUse·=·!pc.IsDead·&&·@object.CanMove·&&·pc.Role.CanUse(this); |
| 55 | » » canUse·=·couldUse; | 55 | » » canUse·=·couldUse; |
| 56 | » » if·(canUse) | 56 | » » if·(canUse) |
| 57 | » » { | 57 | » » { |
| 58 | » » » Vector2·truePosition·=·@object.GetTruePosition(); | 58 | » » » Vector2·truePosition·=·@object.GetTruePosition(); |
| 59 | » » » Vector3·position·=·base.transform.position; | 59 | » » » Vector3·position·=·base.transform.position; |
| 60 | » » » num·=·Vector2.Distance(truePosition,·position); | 60 | » » » num·=·Vector2.Distance(truePosition,·position); |
| 61 | » » » canUse·&=·num·<=·this.UsableDistance·&&·!PhysicsHelpers.AnythingBetween(truePosition,·position,·Constants.ShipOnlyMask,·false); | 61 | » » » canUse·&=·num·<=·this.UsableDistance·&&·!PhysicsHelpers.AnythingBetween(truePosition,·position,·Constants.ShipOnlyMask,·false); |
| Offset 72, 15 lines modified | Offset 72, 15 lines modified | ||
| 72 | 72 | ||
| 73 | » public·void·Use() | 73 | » public·void·Use() |
| 74 | » { | 74 | » { |
| 75 | » » if·(this.IsCoolingDown()) | 75 | » » if·(this.IsCoolingDown()) |
| 76 | » » { | 76 | » » { |
| 77 | » » » return; | 77 | » » » return; |
| 78 | » » } | 78 | » » } |
| 79 | » » | 79 | » » NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data; |
| 80 | » » bool·flag; | 80 | » » bool·flag; |
| 81 | » » bool·flag2; | 81 | » » bool·flag2; |
| 82 | » » this.CanUse(data,·out·flag,·out·flag2); | 82 | » » this.CanUse(data,·out·flag,·out·flag2); |
| 83 | » » if·(flag) | 83 | » » if·(flag) |
| 84 | » » { | 84 | » » { |
| 85 | » » » PlayerControl.LocalPlayer.MyPhysics.RpcClimbLadder(this); | 85 | » » » PlayerControl.LocalPlayer.MyPhysics.RpcClimbLadder(this); |
| 86 | » » » this.CoolDown·=·this.MaxCoolDown; | 86 | » » » this.CoolDown·=·this.MaxCoolDown; |
| Offset 256, 16 lines modified | Offset 256, 16 lines modified | ||
| 256 | 256 | ||
| 257 | » [SerializeField] | 257 | » [SerializeField] |
| 258 | » private·SpriteRenderer·buffButton; | 258 | » private·SpriteRenderer·buffButton; |
| 259 | 259 | ||
| 260 | » [SerializeField] | 260 | » [SerializeField] |
| 261 | » private·SpriteRenderer·hands; | 261 | » private·SpriteRenderer·hands; |
| 262 | 262 | ||
| 263 | » [Header("Sounds")] | ||
| 264 | » [SerializeField] | 263 | » [SerializeField] |
| 264 | » [Header("Sounds")] | ||
| 265 | » private·AudioClip·startLiftingSound; | 265 | » private·AudioClip·startLiftingSound; |
| 266 | 266 | ||
| 267 | » [SerializeField] | 267 | » [SerializeField] |
| 268 | » private·AudioClip·barfillSound; | 268 | » private·AudioClip·barfillSound; |
| 269 | 269 | ||
| 270 | » [SerializeField] | 270 | » [SerializeField] |
| 271 | » private·AudioClip·completeRepSound; | 271 | » private·AudioClip·completeRepSound; |
| Offset 361, 16 lines modified | Offset 361, 16 lines modified | ||
| 361 | 361 | ||
| 362 | » [SerializeField] | 362 | » [SerializeField] |
| 363 | » private·Material·lightCutawayMaterial; | 363 | » private·Material·lightCutawayMaterial; |
| 364 | 364 | ||
| 365 | » [SerializeField] | 365 | » [SerializeField] |
| 366 | » private·Mesh·lightChildMesh; | 366 | » private·Mesh·lightChildMesh; |
| 367 | 367 | ||
| 368 | » [SerializeField] | ||
| 369 | » [Space(10f)] | 368 | » [Space(10f)] |
| 369 | » [SerializeField] | ||
| 370 | » private·LightSourceRendererType·rendererType; | 370 | » private·LightSourceRendererType·rendererType; |
| 371 | 371 | ||
| 372 | » [SerializeField] | 372 | » [SerializeField] |
| 373 | » private·bool·useFlashlight; | 373 | » private·bool·useFlashlight; |
| 374 | 374 | ||
| 375 | » [Header("GPU·Settings")] | 375 | » [Header("GPU·Settings")] |
| 376 | » [SerializeField] | 376 | » [SerializeField] |
| Offset 45, 36 lines modified | Offset 45, 32 lines modified | ||
| 45 | » private·IEnumerator·DelayPlayDropshipAmbience() | 45 | » private·IEnumerator·DelayPlayDropshipAmbience() |
| 46 | » { | 46 | » { |
| 47 | » » SoundManager.Instance.StopAllSound(); | 47 | » » SoundManager.Instance.StopAllSound(); |
| 48 | » » yield·return·new·WaitForSeconds(0.5f); | 48 | » » yield·return·new·WaitForSeconds(0.5f); |
| 49 | » » AudioSource·audioSource·=·SoundManager.Instance.PlayNamedSound("DropShipAmb",·this.DropShipSound,·true,·SoundManager.Instance.AmbienceChannel); | 49 | » » AudioSource·audioSource·=·SoundManager.Instance.PlayNamedSound("DropShipAmb",·this.DropShipSound,·true,·SoundManager.Instance.AmbienceChannel); |
| 50 | » » audioSource.loop·=·true; | 50 | » » audioSource.loop·=·true; |
| 51 | » » audioSource.pitch·=·1.2f; | 51 | » » audioSource.pitch·=·1.2f; |
| 52 | » » SoundManager.Instance.CrossFadeSound("MapTheme",·this.MapTheme,·0.5f,·1.5f); | ||
| 52 | » » yield·break; | 53 | » » yield·break; |
| 53 | » } | 54 | » } |
| 54 | 55 | ||
| 55 | » public·void·FixedUpdate() | 56 | » public·void·FixedUpdate() |
| 56 | » { | 57 | » { |
| 57 | » » this.optionsTimer·+=·Time.fixedDeltaTime; | 58 | » » this.optionsTimer·+=·Time.fixedDeltaTime; |
| 58 | » » if·(this.optionsTimer·<·0.25f) | 59 | » » if·(this.optionsTimer·<·0.25f) |
| 59 | » » { | 60 | » » { |
| 60 | » » » return; | 61 | » » » return; |
| 61 | » » } | 62 | » » } |
| 62 | » » this.optionsTimer·=·0f; | 63 | » » this.optionsTimer·=·0f; |
| 63 | » » if·(GameOptionsManager.Instance.CurrentGameOptions·!=·null) | ||
| 64 | » » { | ||
| 65 | » » » int·num·=·(GameData.Instance·?·GameData.Instance.PlayerCount·:·10); | ||
| 66 | » » » DestroyableSingleton<HudManager>.Instance.GameSettings.text·=·GameOptionsManager.Instance.CurrentGameOptions.ToHudString(num); | ||
| 67 | » » » DestroyableSingleton<HudManager>.Instance.GameSettings.gameObject.SetActive(true); | ||
| 68 | » » } | ||
| 69 | » } | 64 | » } |
| 70 | 65 | ||
| 71 | » public·override·void·OnDestroy() | 66 | » public·override·void·OnDestroy() |
| 72 | » { | 67 | » { |
| 73 | » » SoundManager.Instance.StopNamedSound("DropShipAmb"); | 68 | » » SoundManager.Instance.StopNamedSound("DropShipAmb"); |
| 69 | » » SoundManager.Instance.CrossFadeSound("MapTheme",·null,·0.5f,·1.5f); | ||
| 74 | » » LobbyDebugCommands.RemoveCommands(); | 70 | » » LobbyDebugCommands.RemoveCommands(); |
| 75 | » » base.OnDestroy(); | 71 | » » base.OnDestroy(); |
| 76 | » } | 72 | » } |
| 77 | 73 | ||
| 78 | » public·override·void·HandleRpc(byte·callId,·MessageReader·reader) | 74 | » public·override·void·HandleRpc(byte·callId,·MessageReader·reader) |
| 79 | » { | 75 | » { |
| 80 | » » if·(callId·==·60) | 76 | » » if·(callId·==·60) |
| Offset 145, 14 lines modified | Offset 141, 18 lines modified | ||
| 145 | 141 | ||
| 146 | » public·AnimationClip·SpawnInClip; | 142 | » public·AnimationClip·SpawnInClip; |
| 147 | 143 | ||
| 148 | » public·Vector2[]·SpawnPositions; | 144 | » public·Vector2[]·SpawnPositions; |
| 149 | 145 | ||
| 150 | » public·AudioClip·DropShipSound; | 146 | » public·AudioClip·DropShipSound; |
| 151 | 147 | ||
| 148 | » public·AudioClip·MapTheme; | ||
| 149 | |||
| 150 | » private·const·string·MAP_THEME_NAME·=·"MapTheme"; | ||
| 151 | |||
| 152 | » public·SkeldShipRoom[]·AllRooms; | 152 | » public·SkeldShipRoom[]·AllRooms; |
| 153 | 153 | ||
| 154 | » private·readonly·global::Logger·logger·=·new·global::Logger("LobbyBehaviour",·global::Logger.Level.Warning,·global::Logger.Category.Network); | 154 | » private·readonly·global::Logger·logger·=·new·global::Logger("LobbyBehaviour",·global::Logger.Level.Warning,·global::Logger.Category.Network); |
| 155 | 155 | ||
| 156 | » private·float·lastFriendsCheckTime; | 156 | » private·float·lastFriendsCheckTime; |
| 157 | 157 | ||
| 158 | » private·float·optionsTimer; | 158 | » private·float·optionsTimer; |
| Offset 1, 11 lines modified | Offset 1, 9 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections; | ||
| 3 | using·Assets.InnerNet; | 2 | using·Assets.InnerNet; |
| 4 | using·InnerNet; | ||
| 5 | using·UnityEngine; | 3 | using·UnityEngine; |
| 6 | 4 | ||
| 7 | public·class·LobbyInviteBar·:·FriendsListBar | 5 | public·class·LobbyInviteBar·:·FriendsListBar |
| 8 | { | 6 | { |
| 9 | » public·void·SetUp(string·puid,·FriendsListUI·parentUI,·string·roomCode,·string·friendCode,·string·playerName) | 7 | » public·void·SetUp(string·puid,·FriendsListUI·parentUI,·string·roomCode,·string·friendCode,·string·playerName) |
| 10 | » { | 8 | » { |
| 11 | » » this.SetUp(puid,·parentUI,·friendCode,·playerName); | 9 | » » this.SetUp(puid,·parentUI,·friendCode,·playerName); |
| Offset 16, 30 lines modified | Offset 14, 17 lines modified | ||
| 16 | » public·void·PressAccept() | 14 | » public·void·PressAccept() |
| 17 | » { | 15 | » { |
| 18 | » » if·(this.hasAccepted) | 16 | » » if·(this.hasAccepted) |
| 19 | » » { | 17 | » » { |
| 20 | » » » return; | 18 | » » » return; |
| 21 | » » } | 19 | » » } |
| 22 | » » this.hasAccepted·=·true; | 20 | » » this.hasAccepted·=·true; |
| 21 | » » DestroyableSingleton<FriendsListManager>.Instance.JoinGameViaFriendInvite(this.roomCode); | ||
| 23 | » » base.StartCoroutine(this.JoinGame()); | ||
| 24 | » } | ||
| 25 | |||
| 26 | » private·IEnumerator·JoinGame() | ||
| 27 | » { | ||
| 28 | » » DestroyableSingleton<FriendsListManager>.Instance.LoadScreen.enabled·=·true; | ||
| 29 | » » if·(AmongUsClient.Instance·&&·AmongUsClient.Instance.AmClient) | ||
| 30 | » » { | ||
| 31 | » » » AmongUsClient.Instance.ExitGame(DisconnectReasons.ExitGame); | ||
| 32 | » » } | ||
| 33 | » » int·num·=·GameCode.GameNameToInt(this.roomCode); | ||
| 34 | » » yield·return·AmongUsClient.Instance.CoJoinOnlineGameFromCode(num); | ||
| 35 | » » DestroyableSingleton<FriendsListManager>.Instance.LoadScreen.enabled·=·false; | ||
| 36 | » » this.parentUI.Close(true); | 22 | » » this.parentUI.Close(true); |
| 37 | » » this.DenyLobbyInvite(); | 23 | » » this.DenyLobbyInvite(); |
| 38 | » » yield·break; | ||
| 39 | » } | 24 | » } |
| 40 | 25 | ||
| 41 | » public·void·DenyLobbyInvite() | 26 | » public·void·DenyLobbyInvite() |
| 42 | » { | 27 | » { |
| 43 | » » DestroyableSingleton<FriendsListManager>.Instance.DenyLobbyInvite(this.puid,·delegate(ResponseState·cb,·Response<ResponseFriendsListRequest>·response) | 28 | » » DestroyableSingleton<FriendsListManager>.Instance.DenyLobbyInvite(this.puid,·delegate(ResponseState·cb,·Response<ResponseFriendsListRequest>·response) |
| 44 | » » { | 29 | » » { |
| 45 | » » » if·(cb·==·ResponseState.Success) | 30 | » » » if·(cb·==·ResponseState.Success) |
| Offset 2, 16 lines modified | Offset 2, 16 lines modified | ||
| 2 | using·UnityEngine; | 2 | using·UnityEngine; |
| 3 | 3 | ||
| 4 | public·class·LobbyTimerExtensionUI·:·MonoBehaviour | 4 | public·class·LobbyTimerExtensionUI·:·MonoBehaviour |
| 5 | { | 5 | { |
| 6 | » private·void·Awake() | 6 | » private·void·Awake() |
| 7 | » { | 7 | » { |
| 8 | » » string·@string·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringUnit,·Array.Empty<object>()); | 8 | » » string·@string·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringUnit,·Array.Empty<object>()); |
| 9 | » » string·text·=·" | 9 | » » string·text·=·"{0}"·+·@string; |
| 10 | » » this.timerTextTemplate·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringMsg2,·new·object[]·{·text·}); | 10 | » » this.timerTextTemplate·=·"<font-weight=800>"·+·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringMsg2,·new·object[]·{·text·}); |
| 11 | » » string·text2·=·"<color=green>{0}"·+·@string·+·"</color>"; | 11 | » » string·text2·=·"<color=green>{0}"·+·@string·+·"</color>"; |
| 12 | » » this.popupTitleText·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringMsg,·new·object[]·{·text2·}); | 12 | » » this.popupTitleText·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringMsg,·new·object[]·{·text2·}); |
| 13 | » » this.popupBodyTextTemplate·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringMsg2,·new·object[]·{·text·}); | 13 | » » this.popupBodyTextTemplate·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringMsg2,·new·object[]·{·text·}); |
| 14 | » » this.popup.button1Text.SetText(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringNo,·Array.Empty<object>()),·true); | 14 | » » this.popup.button1Text.SetText(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringNo,·Array.Empty<object>()),·true); |
| 15 | » » this.popup.button2Text.SetText(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringOk,·Array.Empty<object>()),·true); | 15 | » » this.popup.button2Text.SetText(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringOk,·Array.Empty<object>()),·true); |
| 16 | » » this.popup.button1.OnClick.AddListener(delegate | 16 | » » this.popup.button1.OnClick.AddListener(delegate |
| 17 | » » { | 17 | » » { |
| Offset 32, 38 lines modified | Offset 32, 42 lines modified | ||
| 32 | » { | 32 | » { |
| 33 | » » this.HideLobbyTimer(); | 33 | » » this.HideLobbyTimer(); |
| 34 | » » this.popup.Close(); | 34 | » » this.popup.Close(); |
| 35 | » } | 35 | » } |
| 36 | 36 | ||
| 37 | » public·void·ShowLobbyTimer(int·timeRemainingSeconds) | 37 | » public·void·ShowLobbyTimer(int·timeRemainingSeconds) |
| 38 | » { | 38 | » { |
| 39 | » » SoundManager.Instance.PlaySound(this.lobbyTimerPopUpSound,·false,·1f,·null); | ||
| 39 | » » this.timerText.SetTimer((float)timeRemainingSeconds,·this.timerTextTemplate); | 40 | » » this.timerText.SetTimer((float)timeRemainingSeconds,·this.timerTextTemplate); |
| 40 | » » this.timerText.gameObject.SetActive(true); | 41 | » » this.timerText.transform.parent.gameObject.SetActive(true); |
| 41 | » } | 42 | » } |
| 42 | 43 | ||
| 43 | » public·void·ShowLobbyTimerPopup(int·timeRemainingSeconds,·int·timeGrantedSeconds) | 44 | » public·void·ShowLobbyTimerPopup(int·timeRemainingSeconds,·int·timeGrantedSeconds) |
| 44 | » { | 45 | » { |
| 45 | » » this.popupTimerText.SetTimer((float)timeRemainingSeconds,·this.popupBodyTextTemplate); | 46 | » » this.popupTimerText.SetTimer((float)timeRemainingSeconds,·this.popupBodyTextTemplate); |
| 46 | » » this.popup.titleTexxt.SetText(string.Format(this.popupTitleText,·timeGrantedSeconds),·true); | 47 | » » this.popup.titleTexxt.SetText(string.Format(this.popupTitleText,·timeGrantedSeconds),·true); |
| 47 | » » this.popup.gameObject.SetActive(true); | 48 | » » this.popup.gameObject.SetActive(true); |
| 48 | » } | 49 | » } |
| 49 | 50 | ||
| 50 | » private·void·HideLobbyTimer() | 51 | » private·void·HideLobbyTimer() |
| 51 | » { | 52 | » { |
| 52 | » » this.timerText.gameObject.SetActive(false); | 53 | » » this.timerText.transform.parent.gameObject.SetActive(false); |
| 53 | » } | 54 | » } |
| 54 | 55 | ||
| 55 | » [SerializeField] | 56 | » [SerializeField] |
| 56 | » private·TimerTextTMP·timerText; | 57 | » private·TimerTextTMP·timerText; |
| 57 | 58 | ||
| 58 | » [SerializeField] | 59 | » [SerializeField] |
| 59 | » private·InfoTextBox·popup; | 60 | » private·InfoTextBox·popup; |
| 60 | 61 | ||
| 61 | » [SerializeField] | 62 | » [SerializeField] |
| 62 | » private·TimerTextTMP·popupTimerText; | 63 | » private·TimerTextTMP·popupTimerText; |
| 63 | 64 | ||
| 65 | » [SerializeField] | ||
| 66 | » private·AudioClip·lobbyTimerPopUpSound; | ||
| 67 | |||
| 64 | » private·string·timerTextTemplate; | 68 | » private·string·timerTextTemplate; |
| 65 | 69 | ||
| 66 | » private·string·popupTitleText; | 70 | » private·string·popupTitleText; |
| 67 | 71 | ||
| 68 | » private·string·popupBodyTextTemplate; | 72 | » private·string·popupBodyTextTemplate; |
| 69 | } | 73 | } |
| Offset 3, 15 lines modified | Offset 3, 15 lines modified | ||
| 3 | using·TMPro; | 3 | using·TMPro; |
| 4 | using·UnityEngine; | 4 | using·UnityEngine; |
| 5 | 5 | ||
| 6 | public·class·LogEntryBubble·:·PoolableBehavior | 6 | public·class·LogEntryBubble·:·PoolableBehavior |
| 7 | { | 7 | { |
| 8 | » public·void·DecorateLog(SecurityLogBehaviour.SecurityLogEntry·entry,·Sprite·backgroundSprite) | 8 | » public·void·DecorateLog(SecurityLogBehaviour.SecurityLogEntry·entry,·Sprite·backgroundSprite) |
| 9 | » { | 9 | » { |
| 10 | » » | 10 | » » NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(entry.PlayerId); |
| 11 | » » if·(playerById·==·null) | 11 | » » if·(playerById·==·null) |
| 12 | » » { | 12 | » » { |
| 13 | » » » Debug.LogError(string.Format("Couldn't·find·player·{0}·for·log",·entry.PlayerId)); | 13 | » » » Debug.LogError(string.Format("Couldn't·find·player·{0}·for·log",·entry.PlayerId)); |
| 14 | » » » return; | 14 | » » » return; |
| 15 | » » } | 15 | » » } |
| 16 | » » this.SetCosmetics(playerById); | 16 | » » this.SetCosmetics(playerById); |
| 17 | » » this.SetText(entry,·playerById); | 17 | » » this.SetText(entry,·playerById); |
| Offset 26, 21 lines modified | Offset 26, 21 lines modified | ||
| 26 | » } | 26 | » } |
| 27 | 27 | ||
| 28 | » private·void·SetBackground(Sprite·backgroundSprite) | 28 | » private·void·SetBackground(Sprite·backgroundSprite) |
| 29 | » { | 29 | » { |
| 30 | » » this.background.sprite·=·backgroundSprite; | 30 | » » this.background.sprite·=·backgroundSprite; |
| 31 | » } | 31 | » } |
| 32 | 32 | ||
| 33 | » private·void·SetCosmetics( | 33 | » private·void·SetCosmetics(NetworkedPlayerInfo·playerData) |
| 34 | » { | 34 | » { |
| 35 | » » this.player.UpdateFromPlayerData(playerData,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ScrollingUI,·false,·null,·true); | 35 | » » this.player.UpdateFromPlayerData(playerData,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ScrollingUI,·false,·null,·true); |
| 36 | » » this.player.ToggleName(false); | 36 | » » this.player.ToggleName(false); |
| 37 | » } | 37 | » } |
| 38 | 38 | ||
| 39 | » private·void·SetText(SecurityLogBehaviour.SecurityLogEntry·entry,· | 39 | » private·void·SetText(SecurityLogBehaviour.SecurityLogEntry·entry,·NetworkedPlayerInfo·playerData) |
| 40 | » { | 40 | » { |
| 41 | » » string·@string·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LogNorth·+·(int)entry.Location,·Array.Empty<object>()); | 41 | » » string·@string·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LogNorth·+·(int)entry.Location,·Array.Empty<object>()); |
| 42 | » » int·colorId·=·playerData.DefaultOutfit.ColorId; | 42 | » » int·colorId·=·playerData.DefaultOutfit.ColorId; |
| 43 | » » string·text·=·this.text.text; | 43 | » » string·text·=·this.text.text; |
| 44 | » » if·(DataManager.Settings.Accessibility.ColorBlindMode) | 44 | » » if·(DataManager.Settings.Accessibility.ColorBlindMode) |
| 45 | » » { | 45 | » » { |
| 46 | » » » string·text2·=·DestroyableSingleton<TranslationController>.Instance.GetString(Palette.ColorNames[colorId],·Array.Empty<object>()).ToLower(); | 46 | » » » string·text2·=·DestroyableSingleton<TranslationController>.Instance.GetString(Palette.ColorNames[colorId],·Array.Empty<object>()).ToLower(); |
| Offset 16, 35 lines modified | Offset 16, 35 lines modified | ||
| 16 | » protected·ValueTuple<int,·int,·int>·GetPlayerCounts() | 16 | » protected·ValueTuple<int,·int,·int>·GetPlayerCounts() |
| 17 | » { | 17 | » { |
| 18 | » » int·num·=·0; | 18 | » » int·num·=·0; |
| 19 | » » int·num2·=·0; | 19 | » » int·num2·=·0; |
| 20 | » » int·num3·=·0; | 20 | » » int·num3·=·0; |
| 21 | » » for·(int·i·=·0;·i·<·GameData.Instance.PlayerCount;·i++) | 21 | » » for·(int·i·=·0;·i·<·GameData.Instance.PlayerCount;·i++) |
| 22 | » » { | 22 | » » { |
| 23 | » » » | 23 | » » » NetworkedPlayerInfo·networkedPlayerInfo·=·GameData.Instance.AllPlayers[i]; |
| 24 | » » » if·( | 24 | » » » if·(!(networkedPlayerInfo·==·null)·&&·!networkedPlayerInfo.Disconnected·&&·!(networkedPlayerInfo.Role·==·null)) |
| 25 | » » » { | 25 | » » » { |
| 26 | » » » » if·( | 26 | » » » » if·(networkedPlayerInfo.Role.IsImpostor) |
| 27 | » » » » { | 27 | » » » » { |
| 28 | » » » » » num3++; | 28 | » » » » » num3++; |
| 29 | » » » » } | 29 | » » » » } |
| 30 | » » » » if·(! | 30 | » » » » if·(!networkedPlayerInfo.IsDead) |
| 31 | » » » » { | 31 | » » » » { |
| 32 | » » » » » if·( | 32 | » » » » » if·(networkedPlayerInfo.Role.IsImpostor) |
| 33 | » » » » » { | 33 | » » » » » { |
| 34 | » » » » » » num2++; | 34 | » » » » » » num2++; |
| 35 | » » » » » } | 35 | » » » » » } |
| 36 | » » » » » else | 36 | » » » » » else |
| 37 | » » » » » { | 37 | » » » » » { |
| 38 | » » » » » » num++; | 38 | » » » » » » num++; |
| 39 | » » » » » } | 39 | » » » » » } |
| 40 | » » » » } | 40 | » » » » } |
| 41 | » » » » else | 41 | » » » » else |
| 42 | » » » » { | 42 | » » » » { |
| 43 | » » » » » ImpostorGhostRole·impostorGhostRole·=· | 43 | » » » » » ImpostorGhostRole·impostorGhostRole·=·networkedPlayerInfo.Role·as·ImpostorGhostRole; |
| 44 | » » » » » if·(impostorGhostRole·!=·null·&&·impostorGhostRole.WasManuallyPicked) | 44 | » » » » » if·(impostorGhostRole·!=·null·&&·impostorGhostRole.WasManuallyPicked) |
| 45 | » » » » » { | 45 | » » » » » { |
| 46 | » » » » » » num2++; | 46 | » » » » » » num2++; |
| 47 | » » » » » } | 47 | » » » » » } |
| 48 | » » » » } | 48 | » » » » } |
| 49 | » » » } | 49 | » » » } |
| 50 | » » } | 50 | » » } |
| Offset 36, 15 lines modified | Offset 36, 15 lines modified | ||
| 36 | » » this.hideAndSeekManager·=·manager; | 36 | » » this.hideAndSeekManager·=·manager; |
| 37 | » » this.timerBarPrefab·=·timerBarPrefab; | 37 | » » this.timerBarPrefab·=·timerBarPrefab; |
| 38 | » } | 38 | » } |
| 39 | 39 | ||
| 40 | » public·bool·SeekerAdminMapEnabled(PlayerControl·player) | 40 | » public·bool·SeekerAdminMapEnabled(PlayerControl·player) |
| 41 | » { | 41 | » { |
| 42 | » » int·item·=·base.GetPlayerCounts().Item1; | 42 | » » int·item·=·base.GetPlayerCounts().Item1; |
| 43 | » » return·!player.inVent·&&·player.Data· | 43 | » » return·!player.inVent·&&·!(player.Data·==·null)·&&·!(player.Data.Role·==·null)·&&·((!player.inVent·&&·player.Data.Role.IsImpostor·&&·this.IsFinalCountdown·&&·this.hideAndSeekManager.LogicOptionsHnS.GetSeekerFinalMap())·||·(player.Data.Role.IsImpostor·&&·item·<=·(GameData.Instance.PlayerCount·-·1)·/·3)); |
| 44 | » } | 44 | » } |
| 45 | 45 | ||
| 46 | » public·void·OnTaskComplete(float·timeDeduction) | 46 | » public·void·OnTaskComplete(float·timeDeduction) |
| 47 | » { | 47 | » { |
| 48 | » » if·(this.timerBar·!=·null) | 48 | » » if·(this.timerBar·!=·null) |
| 49 | » » { | 49 | » » { |
| 50 | » » » this.timerBar.TaskComplete(); | 50 | » » » this.timerBar.TaskComplete(); |
| Offset 99, 15 lines modified | Offset 99, 15 lines modified | ||
| 99 | » » » } | 99 | » » » } |
| 100 | » » } | 100 | » » } |
| 101 | » » else·if·(item·<=·item2) | 101 | » » else·if·(item·<=·item2) |
| 102 | » » { | 102 | » » { |
| 103 | » » » if·(!DestroyableSingleton<TutorialManager>.InstanceExists) | 103 | » » » if·(!DestroyableSingleton<TutorialManager>.InstanceExists) |
| 104 | » » » { | 104 | » » » { |
| 105 | » » » » GameOverReason·gameOverReason2; | 105 | » » » » GameOverReason·gameOverReason2; |
| 106 | » » » » switch·( | 106 | » » » » switch·(GameData.LastDeathReason) |
| 107 | » » » » { | 107 | » » » » { |
| 108 | » » » » case·DeathReason.Exile: | 108 | » » » » case·DeathReason.Exile: |
| 109 | » » » » » gameOverReason2·=·GameOverReason.ImpostorByVote; | 109 | » » » » » gameOverReason2·=·GameOverReason.ImpostorByVote; |
| 110 | » » » » » break; | 110 | » » » » » break; |
| 111 | » » » » case·DeathReason.Kill: | 111 | » » » » case·DeathReason.Kill: |
| 112 | » » » » » gameOverReason2·=·GameOverReason.ImpostorByKill; | 112 | » » » » » gameOverReason2·=·GameOverReason.ImpostorByKill; |
| 113 | » » » » » break; | 113 | » » » » » break; |
| Offset 18, 15 lines modified | Offset 18, 15 lines modified | ||
| 18 | » » { | 18 | » » { |
| 19 | » » » this.dangerMeter·=·DestroyableSingleton<HudManager>.Instance.DangerMeter; | 19 | » » » this.dangerMeter·=·DestroyableSingleton<HudManager>.Instance.DangerMeter; |
| 20 | » » » this.dangerMeter.gameObject.SetActive(true); | 20 | » » » this.dangerMeter.gameObject.SetActive(true); |
| 21 | » » } | 21 | » » } |
| 22 | » » this.impostors·=·new·List<PlayerControl>(); | 22 | » » this.impostors·=·new·List<PlayerControl>(); |
| 23 | » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) | 23 | » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) |
| 24 | » » { | 24 | » » { |
| 25 | » » » | 25 | » » » NetworkedPlayerInfo·data·=·playerControl.Data; |
| 26 | » » » if·(((data·!=·null)·?·data.Role·:·null)·!=·null·&&·playerControl.Data.Role.IsImpostor) | 26 | » » » if·(((data·!=·null)·?·data.Role·:·null)·!=·null·&&·playerControl.Data.Role.IsImpostor) |
| 27 | » » » { | 27 | » » » { |
| 28 | » » » » this.impostors.Add(playerControl); | 28 | » » » » this.impostors.Add(playerControl); |
| 29 | » » » } | 29 | » » » } |
| 30 | » » } | 30 | » » } |
| 31 | » » this.scaryMusicDistance·=·this.hnsManager.LogicOptionsHnS.GetScaryMusicDistance()·*·this.hnsManager.LogicOptionsHnS.PlayerSpeedBase; | 31 | » » this.scaryMusicDistance·=·this.hnsManager.LogicOptionsHnS.GetScaryMusicDistance()·*·this.hnsManager.LogicOptionsHnS.PlayerSpeedBase; |
| 32 | » » this.veryScaryMusicDistance·=·this.hnsManager.LogicOptionsHnS.GetVeryScaryMusicDistance()·*·this.hnsManager.LogicOptionsHnS.PlayerSpeedBase; | 32 | » » this.veryScaryMusicDistance·=·this.hnsManager.LogicOptionsHnS.GetVeryScaryMusicDistance()·*·this.hnsManager.LogicOptionsHnS.PlayerSpeedBase; |
| Offset 106, 15 lines modified | Offset 106, 16 lines modified | ||
| 106 | » » } | 106 | » » } |
| 107 | » » this.UpdateDangerMeter(); | 107 | » » this.UpdateDangerMeter(); |
| 108 | » » this.UpdateDangerMusic(); | 108 | » » this.UpdateDangerMusic(); |
| 109 | » } | 109 | » } |
| 110 | 110 | ||
| 111 | » private·void·UpdateDangerMusic() | 111 | » private·void·UpdateDangerMusic() |
| 112 | » { | 112 | » { |
| 113 | » » | 113 | » » PlayerControl·localPlayer·=·PlayerControl.LocalPlayer; |
| 114 | » » if·(localPlayer·!=·null·&&·localPlayer.Data·!=·null·&&·localPlayer.Data.IsDead) | ||
| 114 | » » { | 115 | » » { |
| 115 | » » » this.hnsManager.LogicMusic.SetTaskState(false); | 116 | » » » this.hnsManager.LogicMusic.SetTaskState(false); |
| 116 | » » » this.hnsManager.LogicMusic.ResetMusic(); | 117 | » » » this.hnsManager.LogicMusic.ResetMusic(); |
| 117 | » » » return; | 118 | » » » return; |
| 118 | » » } | 119 | » » } |
| 119 | » » this.hnsManager.LogicMusic.SetMusicValues(this.dangerLevel1,·this.dangerLevel2); | 120 | » » this.hnsManager.LogicMusic.SetMusicValues(this.dangerLevel1,·this.dangerLevel2); |
| 120 | » } | 121 | » } |
| Offset 126, 15 lines modified | Offset 126, 15 lines modified | ||
| 126 | » public·void·SetMusicCrossfadeSpeed(float·lerpSpeed) | 126 | » public·void·SetMusicCrossfadeSpeed(float·lerpSpeed) |
| 127 | » { | 127 | » { |
| 128 | » » this.musicLerpSpeed·=·lerpSpeed; | 128 | » » this.musicLerpSpeed·=·lerpSpeed; |
| 129 | » } | 129 | » } |
| 130 | 130 | ||
| 131 | » public·void·SetMusicValues(float·dangerLevel1,·float·dangerLevel2) | 131 | » public·void·SetMusicValues(float·dangerLevel1,·float·dangerLevel2) |
| 132 | » { | 132 | » { |
| 133 | » » if·(PlayerControl.LocalPlayer.Data.Role.IsImpostor) | 133 | » » if·(PlayerControl.LocalPlayer·!=·null·&&·PlayerControl.LocalPlayer.Data.Role.IsImpostor) |
| 134 | » » { | 134 | » » { |
| 135 | » » » return; | 135 | » » » return; |
| 136 | » » } | 136 | » » } |
| 137 | » » if·(this.normalSource·==·null·||·this.taskSource·==·null·||·this.dangerLevel1Source·==·null·||·this.dangerLevel2Source·==·null) | 137 | » » if·(this.normalSource·==·null·||·this.taskSource·==·null·||·this.dangerLevel1Source·==·null·||·this.dangerLevel2Source·==·null) |
| 138 | » » { | 138 | » » { |
| 139 | » » » return; | 139 | » » » return; |
| 140 | » » } | 140 | » » } |
| Offset 149, 14 lines modified | Offset 149, 80 lines modified | ||
| 149 | » » if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.ScientistBatteryCharge,·out·num)) | 149 | » » if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.ScientistBatteryCharge,·out·num)) |
| 150 | » » { | 150 | » » { |
| 151 | » » » return·1f; | 151 | » » » return·1f; |
| 152 | » » } | 152 | » » } |
| 153 | » » return·num; | 153 | » » return·num; |
| 154 | » } | 154 | » } |
| 155 | 155 | ||
| 156 | » public·virtual·float·GetPhantomCooldown() | ||
| 157 | » { | ||
| 158 | » » float·num; | ||
| 159 | » » if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.PhantomCooldown,·out·num)) | ||
| 160 | » » { | ||
| 161 | » » » return·1f; | ||
| 162 | » » } | ||
| 163 | » » return·num; | ||
| 164 | » } | ||
| 165 | |||
| 166 | » public·virtual·float·GetPhantomDuration() | ||
| 167 | » { | ||
| 168 | » » float·num; | ||
| 169 | » » if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.PhantomDuration,·out·num)) | ||
| 170 | » » { | ||
| 171 | » » » return·1f; | ||
| 172 | » » } | ||
| 173 | » » return·num; | ||
| 174 | » } | ||
| 175 | |||
| 176 | » public·virtual·float·GetTrackerCooldown() | ||
| 177 | » { | ||
| 178 | » » float·num; | ||
| 179 | » » if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.TrackerCooldown,·out·num)) | ||
| 180 | » » { | ||
| 181 | » » » return·1f; | ||
| 182 | » » } | ||
| 183 | » » return·num; | ||
| 184 | » } | ||
| 185 | |||
| 186 | » public·virtual·float·GetTrackerDuration() | ||
| 187 | » { | ||
| 188 | » » float·num; | ||
| 189 | » » if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.TrackerDuration,·out·num)) | ||
| 190 | » » { | ||
| 191 | » » » return·1f; | ||
| 192 | » » } | ||
| 193 | » » return·num; | ||
| 194 | » } | ||
| 195 | |||
| 196 | » public·virtual·float·GetTrackerDelay() | ||
| 197 | » { | ||
| 198 | » » float·num; | ||
| 199 | » » if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.TrackerDelay,·out·num)) | ||
| 200 | » » { | ||
| 201 | » » » return·1f; | ||
| 202 | » » } | ||
| 203 | » » return·num; | ||
| 204 | » } | ||
| 205 | |||
| 206 | » public·virtual·bool·GetNoisemakerImpostorAlert() | ||
| 207 | » { | ||
| 208 | » » bool·flag; | ||
| 209 | » » return·this.currentGameOptions.TryGetBool(BoolOptionNames.NoisemakerImpostorAlert,·out·flag)·&&·flag; | ||
| 210 | » } | ||
| 211 | |||
| 212 | » public·virtual·float·GetNoisemakerAlertDuration() | ||
| 213 | » { | ||
| 214 | » » float·num; | ||
| 215 | » » if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.NoisemakerAlertDuration,·out·num)) | ||
| 216 | » » { | ||
| 217 | » » » return·1f; | ||
| 218 | » » } | ||
| 219 | » » return·num; | ||
| 220 | » } | ||
| 221 | |||
| 156 | » public·virtual·float·GetKillCooldown() | 222 | » public·virtual·float·GetKillCooldown() |
| 157 | » { | 223 | » { |
| 158 | » » float·num; | 224 | » » float·num; |
| 159 | » » if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.KillCooldown,·out·num)) | 225 | » » if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.KillCooldown,·out·num)) |
| 160 | » » { | 226 | » » { |
| 161 | » » » return·1f; | 227 | » » » return·1f; |
| 162 | » » } | 228 | » » } |
| Offset 7, 15 lines modified | Offset 7, 15 lines modified | ||
| 7 | { | 7 | { |
| 8 | » public·LogicOptionsHnS(HideAndSeekManager·manager) | 8 | » public·LogicOptionsHnS(HideAndSeekManager·manager) |
| 9 | » » :·base(manager) | 9 | » » :·base(manager) |
| 10 | » { | 10 | » { |
| 11 | » » this.HnSManager·=·manager; | 11 | » » this.HnSManager·=·manager; |
| 12 | » » if·(AmongUsClient.Instance.AmHost) | 12 | » » if·(AmongUsClient.Instance.AmHost) |
| 13 | » » { | 13 | » » { |
| 14 | » » » this.GameOptions·=·GameOptionsManager.Instance.CurrentGameOptions·as·HideNSeekGameOptionsV0 | 14 | » » » this.GameOptions·=·GameOptionsManager.Instance.CurrentGameOptions·as·HideNSeekGameOptionsV08; |
| 15 | » » » this.GameOptions.ImpostorPlayerID·=·-1; | 15 | » » » this.GameOptions.ImpostorPlayerID·=·-1; |
| 16 | » » } | 16 | » » } |
| 17 | » } | 17 | » } |
| 18 | 18 | ||
| 19 | » public·float·PlayerSpeedBase | 19 | » public·float·PlayerSpeedBase |
| 20 | » { | 20 | » { |
| 21 | » » get | 21 | » » get |
| Offset 44, 15 lines modified | Offset 44, 15 lines modified | ||
| 44 | » » » num·*=·this.GameOptions.SeekerFinalSpeed; | 44 | » » » num·*=·this.GameOptions.SeekerFinalSpeed; |
| 45 | » » } | 45 | » » } |
| 46 | » » return·num; | 46 | » » return·num; |
| 47 | » } | 47 | » } |
| 48 | 48 | ||
| 49 | » public·override·float·GetKillDistance() | 49 | » public·override·float·GetKillDistance() |
| 50 | » { | 50 | » { |
| 51 | » » return·HideNSeekGameOptionsV0 | 51 | » » return·HideNSeekGameOptionsV08.KillDistances[Mathf.Clamp(this.GameOptions.KillDistance,·0,·HideNSeekGameOptionsV08.KillDistances.Length·-·1)]; |
| 52 | » } | 52 | » } |
| 53 | 53 | ||
| 54 | » public·override·float·GetEngineerCooldown() | 54 | » public·override·float·GetEngineerCooldown() |
| 55 | » { | 55 | » { |
| 56 | » » return·this.GetCrewmateVentCooldown(); | 56 | » » return·this.GetCrewmateVentCooldown(); |
| 57 | » } | 57 | » } |
| 58 | 58 | ||
| Offset 127, 17 lines modified | Offset 127, 17 lines modified | ||
| 127 | » } | 127 | » } |
| 128 | 128 | ||
| 129 | » public·bool·HasImpostorPlayerID() | 129 | » public·bool·HasImpostorPlayerID() |
| 130 | » { | 130 | » { |
| 131 | » » return·this.GameOptions.ImpostorPlayerID·>·-1; | 131 | » » return·this.GameOptions.ImpostorPlayerID·>·-1; |
| 132 | » } | 132 | » } |
| 133 | 133 | ||
| 134 | » public·bool·ValidateImpostorPlayerID(List< | 134 | » public·bool·ValidateImpostorPlayerID(List<NetworkedPlayerInfo>·players) |
| 135 | » { | 135 | » { |
| 136 | » » return·this.HasImpostorPlayerID()·&&·players.Find(( | 136 | » » return·this.HasImpostorPlayerID()·&&·players.Find((NetworkedPlayerInfo·p)·=>·(int)p.PlayerId·==·this.ImpostorPlayerID())·!=·null; |
| 137 | » } | 137 | » } |
| 138 | 138 | ||
| 139 | » public·bool·GetSeekerPings() | 139 | » public·bool·GetSeekerPings() |
| 140 | » { | 140 | » { |
| 141 | » » return·this.GameOptions.SeekerPings; | 141 | » » return·this.GameOptions.SeekerPings; |
| 142 | » } | 142 | » } |
| 143 | 143 | ||
| Offset 203, 21 lines modified | Offset 203, 21 lines modified | ||
| 203 | » » { | 203 | » » { |
| 204 | » » » return·this.GameOptions; | 204 | » » » return·this.GameOptions; |
| 205 | » » } | 205 | » » } |
| 206 | » } | 206 | » } |
| 207 | 207 | ||
| 208 | » protected·override·void·SetGameOptions(IGameOptions·newOptions) | 208 | » protected·override·void·SetGameOptions(IGameOptions·newOptions) |
| 209 | » { | 209 | » { |
| 210 | » » this.GameOptions·=·newOptions·as·HideNSeekGameOptionsV0 | 210 | » » this.GameOptions·=·newOptions·as·HideNSeekGameOptionsV08; |
| 211 | » » base.SetDirty(); | 211 | » » base.SetDirty(); |
| 212 | » } | 212 | » } |
| 213 | 213 | ||
| 214 | » private·const·float·CommonShortTaskTime·=·5f; | 214 | » private·const·float·CommonShortTaskTime·=·5f; |
| 215 | 215 | ||
| 216 | » private·const·float·LongTaskTime·=·10f; | 216 | » private·const·float·LongTaskTime·=·10f; |
| 217 | 217 | ||
| 218 | » private·const·float·TaskTimePlayerDelta·=·1f; | 218 | » private·const·float·TaskTimePlayerDelta·=·1f; |
| 219 | 219 | ||
| 220 | » private·HideNSeekGameOptionsV0 | 220 | » private·HideNSeekGameOptionsV08·GameOptions; |
| 221 | 221 | ||
| 222 | » private·HideAndSeekManager·HnSManager; | 222 | » private·HideAndSeekManager·HnSManager; |
| 223 | } | 223 | } |
| Offset 4, 15 lines modified | Offset 4, 15 lines modified | ||
| 4 | public·class·LogicOptionsNormal·:·LogicOptions | 4 | public·class·LogicOptionsNormal·:·LogicOptions |
| 5 | { | 5 | { |
| 6 | » public·LogicOptionsNormal(GameManager·manager) | 6 | » public·LogicOptionsNormal(GameManager·manager) |
| 7 | » » :·base(manager) | 7 | » » :·base(manager) |
| 8 | » { | 8 | » { |
| 9 | » » if·(AmongUsClient.Instance.AmHost) | 9 | » » if·(AmongUsClient.Instance.AmHost) |
| 10 | » » { | 10 | » » { |
| 11 | » » » this.GameOptions·=·GameOptionsManager.Instance.CurrentGameOptions·as·NormalGameOptionsV0 | 11 | » » » this.GameOptions·=·GameOptionsManager.Instance.CurrentGameOptions·as·NormalGameOptionsV08; |
| 12 | » » } | 12 | » » } |
| 13 | » } | 13 | » } |
| 14 | 14 | ||
| 15 | » public·int·GetDiscussionTime() | 15 | » public·int·GetDiscussionTime() |
| 16 | » { | 16 | » { |
| 17 | » » return·this.GameOptions.DiscussionTime; | 17 | » » return·this.GameOptions.DiscussionTime; |
| 18 | » } | 18 | » } |
| Offset 74, 13 lines modified | Offset 74, 13 lines modified | ||
| 74 | » » { | 74 | » » { |
| 75 | » » » return·this.GameOptions; | 75 | » » » return·this.GameOptions; |
| 76 | » » } | 76 | » » } |
| 77 | » } | 77 | » } |
| 78 | 78 | ||
| 79 | » protected·override·void·SetGameOptions(IGameOptions·newOptions) | 79 | » protected·override·void·SetGameOptions(IGameOptions·newOptions) |
| 80 | » { | 80 | » { |
| 81 | » » this.GameOptions·=·newOptions·as·NormalGameOptionsV0 | 81 | » » this.GameOptions·=·newOptions·as·NormalGameOptionsV08; |
| 82 | » » base.SetDirty(); | 82 | » » base.SetDirty(); |
| 83 | » } | 83 | » } |
| 84 | 84 | ||
| 85 | » private·NormalGameOptionsV0 | 85 | » private·NormalGameOptionsV08·GameOptions; |
| 86 | } | 86 | } |
| Offset 5, 11 lines modified | Offset 5, 11 lines modified | ||
| 5 | public·abstract·class·LogicRoleSelection·:·GameLogicComponent | 5 | public·abstract·class·LogicRoleSelection·:·GameLogicComponent |
| 6 | { | 6 | { |
| 7 | » public·LogicRoleSelection(GameManager·manager) | 7 | » public·LogicRoleSelection(GameManager·manager) |
| 8 | » » :·base(manager) | 8 | » » :·base(manager) |
| 9 | » { | 9 | » { |
| 10 | » } | 10 | » } |
| 11 | 11 | ||
| 12 | » public·abstract·void·AssignRolesForTeam(List< | 12 | » public·abstract·void·AssignRolesForTeam(List<NetworkedPlayerInfo>·players,·IGameOptions·opts,·RoleTeamTypes·team,·int·teamMax,·RoleTypes?·defaultRole); |
| 13 | 13 | ||
| 14 | » public·abstract·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole); | 14 | » public·abstract·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole); |
| 15 | } | 15 | } |
| Offset 32, 49 lines modified | Offset 32, 49 lines modified | ||
| 32 | » » return·false; | 32 | » » return·false; |
| 33 | » } | 33 | » } |
| 34 | 34 | ||
| 35 | » public·override·void·Deserialize(MessageReader·reader,·bool·initialState) | 35 | » public·override·void·Deserialize(MessageReader·reader,·bool·initialState) |
| 36 | » { | 36 | » { |
| 37 | » } | 37 | » } |
| 38 | 38 | ||
| 39 | » public·override·void·AssignRolesForTeam(List< | 39 | » public·override·void·AssignRolesForTeam(List<NetworkedPlayerInfo>·players,·IGameOptions·opts,·RoleTeamTypes·team,·int·teamMax,·RoleTypes?·defaultRole) |
| 40 | » { | 40 | » { |
| 41 | » » if·(team·==·RoleTeamTypes.Crewmate) | 41 | » » if·(team·==·RoleTeamTypes.Crewmate) |
| 42 | » » { | 42 | » » { |
| 43 | » » » players.ForEach(delegate( | 43 | » » » players.ForEach(delegate(NetworkedPlayerInfo·player) |
| 44 | » » » { | 44 | » » » { |
| 45 | » » » » player.Object.RpcSetRole(RoleTypes.Engineer); | 45 | » » » » player.Object.RpcSetRole(RoleTypes.Engineer,·false); |
| 46 | » » » }); | 46 | » » » }); |
| 47 | » » » return; | 47 | » » » return; |
| 48 | » » } | 48 | » » } |
| 49 | » » bool·flag·=·!AmongUsClient.Instance.IsGamePublic; | 49 | » » bool·flag·=·!AmongUsClient.Instance.IsGamePublic; |
| 50 | » » if·(this.hnsManager.LogicOptionsHnS.HasImpostorPlayerID()·&&·this.hnsManager.LogicOptionsHnS.ValidateImpostorPlayerID(players)·&&·flag) | 50 | » » if·(this.hnsManager.LogicOptionsHnS.HasImpostorPlayerID()·&&·this.hnsManager.LogicOptionsHnS.ValidateImpostorPlayerID(players)·&&·flag) |
| 51 | » » { | 51 | » » { |
| 52 | » » » | 52 | » » » NetworkedPlayerInfo·networkedPlayerInfo·=·players.Find((NetworkedPlayerInfo·p)·=>·(int)p.PlayerId·==·this.hnsManager.LogicOptionsHnS.ImpostorPlayerID()); |
| 53 | » » » | 53 | » » » networkedPlayerInfo.Object.RpcSetRole(RoleTypes.Impostor,·false); |
| 54 | » » » players.Remove( | 54 | » » » players.Remove(networkedPlayerInfo); |
| 55 | » » » return; | 55 | » » » return; |
| 56 | » » } | 56 | » » } |
| 57 | » » this.PickSeekersRoundRobin(players,·teamMax); | 57 | » » this.PickSeekersRoundRobin(players,·teamMax); |
| 58 | » } | 58 | » } |
| 59 | 59 | ||
| 60 | » private·void·PickSeekersRoundRobin(List< | 60 | » private·void·PickSeekersRoundRobin(List<NetworkedPlayerInfo>·players,·int·teamMax) |
| 61 | » { | 61 | » { |
| 62 | » » int·num·=·0; | 62 | » » int·num·=·0; |
| 63 | » » while·(num·<·teamMax·&&·players.Count·>·0) | 63 | » » while·(num·<·teamMax·&&·players.Count·>·0) |
| 64 | » » { | 64 | » » { |
| 65 | » » » PseudoRandomList< | 65 | » » » PseudoRandomList<NetworkedPlayerInfo>·pseudoRandomList·=·new·PseudoRandomList<NetworkedPlayerInfo>(AmongUsClient.Instance.GameId); |
| 66 | » » » pseudoRandomList.AddRange(players); | 66 | » » » pseudoRandomList.AddRange(players); |
| 67 | » » » for·(int·i·=·0;·i·<· | 67 | » » » for·(int·i·=·0;·i·<·GameData.RoundsPlayedInSession;·i++) |
| 68 | » » » { | 68 | » » » { |
| 69 | » » » » pseudoRandomList.PickRandom(); | 69 | » » » » pseudoRandomList.PickRandom(); |
| 70 | » » » } | 70 | » » » } |
| 71 | » » » | 71 | » » » NetworkedPlayerInfo·networkedPlayerInfo·=·pseudoRandomList.PickRandom(); |
| 72 | » » » | 72 | » » » networkedPlayerInfo.Object.RpcSetRole(RoleTypes.Impostor,·false); |
| 73 | » » » players.Remove( | 73 | » » » players.Remove(networkedPlayerInfo); |
| 74 | » » » num++; | 74 | » » » num++; |
| 75 | » » } | 75 | » » } |
| 76 | » } | 76 | » } |
| 77 | 77 | ||
| 78 | » public·override·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole) | 78 | » public·override·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole) |
| 79 | » { | 79 | » { |
| 80 | » » if·(AmongUsClient.Instance.AmHost·&&·assignGhostRole) | 80 | » » if·(AmongUsClient.Instance.AmHost·&&·assignGhostRole) |
| Offset 32, 15 lines modified | Offset 32, 15 lines modified | ||
| 32 | » » return·false; | 32 | » » return·false; |
| 33 | » } | 33 | » } |
| 34 | 34 | ||
| 35 | » public·override·void·Deserialize(MessageReader·reader,·bool·initialState) | 35 | » public·override·void·Deserialize(MessageReader·reader,·bool·initialState) |
| 36 | » { | 36 | » { |
| 37 | » } | 37 | » } |
| 38 | 38 | ||
| 39 | » public·override·void·AssignRolesForTeam(List< | 39 | » public·override·void·AssignRolesForTeam(List<NetworkedPlayerInfo>·players,·IGameOptions·opts,·RoleTeamTypes·team,·int·teamMax,·RoleTypes?·defaultRole) |
| 40 | » { | 40 | » { |
| 41 | » » int·num·=·0; | 41 | » » int·num·=·0; |
| 42 | » » IEnumerable<RoleBehaviour>·enumerable·=·Enumerable.Where<RoleBehaviour>(DestroyableSingleton<RoleManager>.Instance.AllRoles,·(RoleBehaviour·role)·=>·role.TeamType·==·team·&&·!RoleManager.IsGhostRole(role.Role)); | 42 | » » IEnumerable<RoleBehaviour>·enumerable·=·Enumerable.Where<RoleBehaviour>(DestroyableSingleton<RoleManager>.Instance.AllRoles,·(RoleBehaviour·role)·=>·role.TeamType·==·team·&&·!RoleManager.IsGhostRole(role.Role)); |
| 43 | » » List<RoleTypes>·list·=·new·List<RoleTypes>(); | 43 | » » List<RoleTypes>·list·=·new·List<RoleTypes>(); |
| 44 | » » IRoleOptionsCollection·roleOptions·=·opts.RoleOptions; | 44 | » » IRoleOptionsCollection·roleOptions·=·opts.RoleOptions; |
| 45 | » » IEnumerable<RoleBehaviour>·enumerable2·=·enumerable; | 45 | » » IEnumerable<RoleBehaviour>·enumerable2·=·enumerable; |
| 46 | » » Func<RoleBehaviour,·bool>·<>9__4; | 46 | » » Func<RoleBehaviour,·bool>·<>9__4; |
| Offset 94, 23 lines modified | Offset 94, 23 lines modified | ||
| 94 | » » » { | 94 | » » » { |
| 95 | » » » » list.Add(defaultRole.Value); | 95 | » » » » list.Add(defaultRole.Value); |
| 96 | » » » } | 96 | » » » } |
| 97 | » » » this.AssignRolesFromList(players,·teamMax,·list,·ref·num); | 97 | » » » this.AssignRolesFromList(players,·teamMax,·list,·ref·num); |
| 98 | » » } | 98 | » » } |
| 99 | » } | 99 | » } |
| 100 | 100 | ||
| 101 | » private·void·AssignRolesFromList(List< | 101 | » private·void·AssignRolesFromList(List<NetworkedPlayerInfo>·players,·int·teamMax,·List<RoleTypes>·roleList,·ref·int·rolesAssigned) |
| 102 | » { | 102 | » { |
| 103 | » » while·(roleList.Count·>·0·&&·players.Count·>·0·&&·rolesAssigned·<·teamMax) | 103 | » » while·(roleList.Count·>·0·&&·players.Count·>·0·&&·rolesAssigned·<·teamMax) |
| 104 | » » { | 104 | » » { |
| 105 | » » » int·num·=·HashRandom.FastNext(roleList.Count); | 105 | » » » int·num·=·HashRandom.FastNext(roleList.Count); |
| 106 | » » » RoleTypes·roleTypes·=·roleList[num]; | 106 | » » » RoleTypes·roleTypes·=·roleList[num]; |
| 107 | » » » roleList.RemoveAt(num); | 107 | » » » roleList.RemoveAt(num); |
| 108 | » » » int·num2·=·HashRandom.FastNext(players.Count); | 108 | » » » int·num2·=·HashRandom.FastNext(players.Count); |
| 109 | » » » players[num2].Object.RpcSetRole(roleTypes); | 109 | » » » players[num2].Object.RpcSetRole(roleTypes,·false); |
| 110 | » » » players.RemoveAt(num2); | 110 | » » » players.RemoveAt(num2); |
| 111 | » » » rolesAssigned++; | 111 | » » » rolesAssigned++; |
| 112 | » » } | 112 | » » } |
| 113 | » } | 113 | » } |
| 114 | 114 | ||
| 115 | » public·override·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole) | 115 | » public·override·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole) |
| 116 | » { | 116 | » { |
| Offset 143, 15 lines modified | Offset 143, 15 lines modified | ||
| 143 | » » » } | 143 | » » » } |
| 144 | » » » if·(this.hideAndSeekImpostor·==·null) | 144 | » » » if·(this.hideAndSeekImpostor·==·null) |
| 145 | » » » { | 145 | » » » { |
| 146 | » » » » return; | 146 | » » » » return; |
| 147 | » » » } | 147 | » » » } |
| 148 | » » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) | 148 | » » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) |
| 149 | » » » { | 149 | » » » { |
| 150 | » » » » | 150 | » » » » NetworkedPlayerInfo·data·=·playerControl.Data; |
| 151 | » » » » if·(((data·!=·null)·?·data.Role·:·null)·!=·null·&&·!playerControl.Data.Role.IsImpostor) | 151 | » » » » if·(((data·!=·null)·?·data.Role·:·null)·!=·null·&&·!playerControl.Data.Role.IsImpostor) |
| 152 | » » » » { | 152 | » » » » { |
| 153 | » » » » » playerControl.cosmetics.GetLongBoi().SetHeighFromDistanceHnS((this.hideAndSeekImpostor.transform.position·-·playerControl.transform.position).sqrMagnitude); | 153 | » » » » » playerControl.cosmetics.GetLongBoi().SetHeighFromDistanceHnS((this.hideAndSeekImpostor.transform.position·-·playerControl.transform.position).sqrMagnitude); |
| 154 | » » » » } | 154 | » » » » } |
| 155 | » » » } | 155 | » » » } |
| 156 | » » } | 156 | » » } |
| 157 | » } | 157 | » } |
| Offset 1, 19 lines modified | Offset 1, 19 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·UnityEngine; | 2 | using·UnityEngine; |
| 3 | 3 | ||
| 4 | public·class·LongModeKillAnimation·:·OverlayKillAnimation | 4 | public·class·LongModeKillAnimation·:·OverlayKillAnimation |
| 5 | { | 5 | { |
| 6 | » public·override·void·Initialize( | 6 | » public·override·void·Initialize(KillOverlayInitData·initData) |
| 7 | » { | 7 | » { |
| 8 | » » base.Initialize( | 8 | » » base.Initialize(initData); |
| 9 | » » PlayerMaterial.SetColors(this.killerParts.ColorId,·this.killerNeck); | 9 | » » PlayerMaterial.SetColors(this.killerParts.ColorId,·this.killerNeck); |
| 10 | » » PlayerMaterial.SetColors(this.killerParts.ColorId,·this.killerHead); | 10 | » » PlayerMaterial.SetColors(this.killerParts.ColorId,·this.killerHead); |
| 11 | » » this.sideHat.SetHat( | 11 | » » this.sideHat.SetHat(initData.killerOutfit.HatId,·this.killerParts.ColorId); |
| 12 | » » this.sideVisor.SetVisor( | 12 | » » this.sideVisor.SetVisor(initData.killerOutfit.VisorId,·this.killerParts.ColorId); |
| 13 | » } | 13 | » } |
| 14 | 14 | ||
| 15 | » [SerializeField] | 15 | » [SerializeField] |
| 16 | » private·SpriteRenderer·killerNeck; | 16 | » private·SpriteRenderer·killerNeck; |
| 17 | 17 | ||
| 18 | » [SerializeField] | 18 | » [SerializeField] |
| 19 | » private·SpriteRenderer·killerHead; | 19 | » private·SpriteRenderer·killerHead; |
| Offset 115, 17 lines modified | Offset 115, 17 lines modified | ||
| 115 | » » { | 115 | » » { |
| 116 | » » » DestroyableSingleton<StoreMenu>.Instance.Initialize(); | 116 | » » » DestroyableSingleton<StoreMenu>.Instance.Initialize(); |
| 117 | » » } | 117 | » » } |
| 118 | » » while·(!DestroyableSingleton<EOSManager>.Instance.HasFinishedLoginFlow()·||·DestroyableSingleton<AccountManager>.Instance.signInScreen.IsOpen()) | 118 | » » while·(!DestroyableSingleton<EOSManager>.Instance.HasFinishedLoginFlow()·||·DestroyableSingleton<AccountManager>.Instance.signInScreen.IsOpen()) |
| 119 | » » { | 119 | » » { |
| 120 | » » » yield·return·new·WaitForSeconds(0.3f); | 120 | » » » yield·return·new·WaitForSeconds(0.3f); |
| 121 | » » } | 121 | » » } |
| 122 | » » DestroyableSingleton<EOSManager>.Instance.announcementsVisible·=·true; | ||
| 123 | » » if·(DataManager.Player.Account.LoginStatus·!=·EOSManager.AccountLoginStatus.Offline) | 122 | » » if·(DataManager.Player.Account.LoginStatus·!=·EOSManager.AccountLoginStatus.Offline) |
| 124 | » » { | 123 | » » { |
| 124 | » » » DestroyableSingleton<EOSManager>.Instance.announcementsVisible·=·true; | ||
| 125 | » » » base.StartCoroutine(this.announcementPopUp.ShowIfNew(delegate | 125 | » » » base.StartCoroutine(this.announcementPopUp.ShowIfNew(delegate |
| 126 | » » » { | 126 | » » » { |
| 127 | » » » » DestroyableSingleton<EOSManager>.Instance.announcementsVisible·=·false; | 127 | » » » » DestroyableSingleton<EOSManager>.Instance.announcementsVisible·=·false; |
| 128 | » » » })); | 128 | » » » })); |
| 129 | » » } | 129 | » » } |
| 130 | » » this.CheckAddOns(); | 130 | » » this.CheckAddOns(); |
| 131 | » » DestroyableSingleton<StoreMenu>.Instance.OnSaveDataChanged(); | 131 | » » DestroyableSingleton<StoreMenu>.Instance.OnSaveDataChanged(); |
| Offset 258, 16 lines modified | Offset 258, 16 lines modified | ||
| 258 | 258 | ||
| 259 | » [SerializeField] | 259 | » [SerializeField] |
| 260 | » private·SpriteRenderer·screenTint; | 260 | » private·SpriteRenderer·screenTint; |
| 261 | 261 | ||
| 262 | » [SerializeField] | 262 | » [SerializeField] |
| 263 | » private·PassiveButton·freePlayButton; | 263 | » private·PassiveButton·freePlayButton; |
| 264 | 264 | ||
| 265 | » [SerializeField] | ||
| 266 | » [Header("Left·panel·buttons")] | 265 | » [Header("Left·panel·buttons")] |
| 266 | » [SerializeField] | ||
| 267 | » private·PassiveButton·playButton; | 267 | » private·PassiveButton·playButton; |
| 268 | 268 | ||
| 269 | » [SerializeField] | 269 | » [SerializeField] |
| 270 | » private·PassiveButton·inventoryButton; | 270 | » private·PassiveButton·inventoryButton; |
| 271 | 271 | ||
| 272 | » [SerializeField] | 272 | » [SerializeField] |
| 273 | » private·PassiveButton·shopButton; | 273 | » private·PassiveButton·shopButton; |
| Offset 283, 16 lines modified | Offset 283, 16 lines modified | ||
| 283 | 283 | ||
| 284 | » [SerializeField] | 284 | » [SerializeField] |
| 285 | » private·PassiveButton·creditsButton; | 285 | » private·PassiveButton·creditsButton; |
| 286 | 286 | ||
| 287 | » [SerializeField] | 287 | » [SerializeField] |
| 288 | » private·PassiveButton·quitButton; | 288 | » private·PassiveButton·quitButton; |
| 289 | 289 | ||
| 290 | » [SerializeField] | ||
| 291 | » [Header("Default·right·panel·buttons")] | 290 | » [Header("Default·right·panel·buttons")] |
| 291 | » [SerializeField] | ||
| 292 | » private·PassiveButton·playLocalButton; | 292 | » private·PassiveButton·playLocalButton; |
| 293 | 293 | ||
| 294 | » [SerializeField] | 294 | » [SerializeField] |
| 295 | » private·PassiveButton·howToPlayButton; | 295 | » private·PassiveButton·howToPlayButton; |
| 296 | 296 | ||
| 297 | » [SerializeField] | 297 | » [SerializeField] |
| 298 | » private·PassiveButton·accountCTAButton; | 298 | » private·PassiveButton·accountCTAButton; |
| Offset 16, 16 lines modified | Offset 16, 21 lines modified | ||
| 16 | » { | 16 | » { |
| 17 | » » get | 17 | » » get |
| 18 | » » { | 18 | » » { |
| 19 | » » » return·this.IsOpen·&&·this.countOverlay.isActiveAndEnabled·&&·!this.countOverlayAllowsMovement; | 19 | » » » return·this.IsOpen·&&·this.countOverlay.isActiveAndEnabled·&&·!this.countOverlayAllowsMovement; |
| 20 | » » } | 20 | » » } |
| 21 | » } | 21 | » } |
| 22 | 22 | ||
| 23 | » public·void·SetPreMeetingPosition(Vector3·preMeetingPosition) | 23 | » public·void·SetPreMeetingPosition(Vector3·preMeetingPosition,·bool·trackedPlayer·=·false) |
| 24 | » { | 24 | » { |
| 25 | » » if·(trackedPlayer) | ||
| 26 | » » { | ||
| 27 | » » » this.trackedPreMeetingPosition·=·new·Vector3?(preMeetingPosition); | ||
| 28 | » » » return; | ||
| 29 | » » } | ||
| 25 | » » this.preMeetingPosition·=·new·Vector3?(preMeetingPosition); | 30 | » » this.preMeetingPosition·=·new·Vector3?(preMeetingPosition); |
| 26 | » } | 31 | » } |
| 27 | 32 | ||
| 28 | » public·void·Show(MapOptions·opts) | 33 | » public·void·Show(MapOptions·opts) |
| 29 | » { | 34 | » { |
| 30 | » » if·(this.IsOpen) | 35 | » » if·(this.IsOpen) |
| 31 | » » { | 36 | » » { |
| Offset 57, 20 lines modified | Offset 62, 30 lines modified | ||
| 57 | » { | 62 | » { |
| 58 | » » global::Logger.GlobalInstance.Debug("GAMEPLAY::MapBehaviour::Closing·map",·null); | 63 | » » global::Logger.GlobalInstance.Debug("GAMEPLAY::MapBehaviour::Closing·map",·null); |
| 59 | » » base.gameObject.SetActive(false); | 64 | » » base.gameObject.SetActive(false); |
| 60 | » » this.countOverlay.gameObject.SetActive(false); | 65 | » » this.countOverlay.gameObject.SetActive(false); |
| 61 | » » this.infectedOverlay.gameObject.SetActive(false); | 66 | » » this.infectedOverlay.gameObject.SetActive(false); |
| 62 | » » this.taskOverlay.Hide(); | 67 | » » this.taskOverlay.Hide(); |
| 63 | » » this.HerePoint.enabled·=·true; | 68 | » » this.HerePoint.enabled·=·true; |
| 69 | » » DestroyableSingleton<HudManager>.Instance.DeselectMapButton(); | ||
| 64 | » » if·(!MeetingHud.Instance) | 70 | » » if·(!MeetingHud.Instance) |
| 65 | » » { | 71 | » » { |
| 66 | » » » DestroyableSingleton<HudManager>.Instance.SetHudActive(true); | 72 | » » » DestroyableSingleton<HudManager>.Instance.SetHudActive(true); |
| 67 | » » } | 73 | » » } |
| 68 | » } | 74 | » } |
| 69 | 75 | ||
| 76 | » public·void·DisableTrackerOverlays() | ||
| 77 | » { | ||
| 78 | » » global::Logger.GlobalInstance.Debug("GAMEPLAY::MapBehaviour::Closing·Tracker·Overlays",·null); | ||
| 79 | » » if·(this.TrackedHerePoint·!=·null) | ||
| 80 | » » { | ||
| 81 | » » » this.TrackedHerePoint.gameObject.SetActive(false); | ||
| 82 | » » } | ||
| 83 | » } | ||
| 84 | |||
| 70 | » private·void·Validate() | 85 | » private·void·Validate() |
| 71 | » { | 86 | » { |
| 72 | » » this.countOverlay.CountAreas.ForEach(delegate(CounterArea·area) | 87 | » » this.countOverlay.CountAreas.ForEach(delegate(CounterArea·area) |
| 73 | » » { | 88 | » » { |
| 74 | » » » if·(area·==·null) | 89 | » » » if·(area·==·null) |
| 75 | » » » { | 90 | » » » { |
| 76 | » » » » Debug.LogError("One·of·the·count·areas·in·the·count·overlay·is·null"); | 91 | » » » » Debug.LogError("One·of·the·count·areas·in·the·count·overlay·is·null"); |
| Offset 122, 28 lines modified | Offset 137, 42 lines modified | ||
| 122 | » » » return; | 137 | » » » return; |
| 123 | » » } | 138 | » » } |
| 124 | » » if·(!PlayerControl.LocalPlayer.CanMove·&&·!MeetingHud.Instance) | 139 | » » if·(!PlayerControl.LocalPlayer.CanMove·&&·!MeetingHud.Instance) |
| 125 | » » { | 140 | » » { |
| 126 | » » » return; | 141 | » » » return; |
| 127 | » » } | 142 | » » } |
| 128 | » » PlayerControl.LocalPlayer.SetPlayerMaterialColors(this.HerePoint); | 143 | » » PlayerControl.LocalPlayer.SetPlayerMaterialColors(this.HerePoint); |
| 144 | » » if·(PlayerControl.LocalPlayer.isTrackingPlayer) | ||
| 145 | » » { | ||
| 146 | » » » if·(PlayerControl.LocalPlayer.trackedPlayer.Data.Disconnected) | ||
| 147 | » » » { | ||
| 148 | » » » » this.TrackedHerePoint.gameObject.SetActive(false); | ||
| 149 | » » » } | ||
| 150 | » » » else | ||
| 151 | » » » { | ||
| 152 | » » » » this.SetTrackedHerePointColor(PlayerControl.LocalPlayer.trackedPlayerColorID); | ||
| 153 | » » » » this.TrackedHerePoint.gameObject.SetActive(true); | ||
| 154 | » » » » this.UpdateTrackedPosition(); | ||
| 155 | » » » } | ||
| 156 | » » } | ||
| 129 | » » this.GenericShow(); | 157 | » » this.GenericShow(); |
| 130 | » » this.taskOverlay.Show(); | 158 | » » this.taskOverlay.Show(); |
| 131 | » » this.ColorControl.SetColor(new·Color(0.05f,·0.2f,·1f,·1f)); | 159 | » » this.ColorControl.SetColor(new·Color(0.05f,·0.2f,·1f,·1f)); |
| 132 | » » DestroyableSingleton<HudManager>.Instance.SetHudActive(false); | 160 | » » DestroyableSingleton<HudManager>.Instance.SetHudActive(false); |
| 133 | » } | 161 | » } |
| 134 | 162 | ||
| 135 | » private·void·ShowCountOverlay(bool·allowedToMove,·bool·showLivePlayerPosition,·bool·includeDeadBodies) | 163 | » private·void·ShowCountOverlay(bool·allowedToMove,·bool·showLivePlayerPosition,·bool·includeDeadBodies) |
| 136 | » { | 164 | » { |
| 137 | » » this.GenericShow(); | 165 | » » this.GenericShow(); |
| 138 | » » this.countOverlay.gameObject.SetActive(true); | 166 | » » this.countOverlay.gameObject.SetActive(true); |
| 139 | » » this.countOverlay.SetOptions(showLivePlayerPosition,·includeDeadBodies); | 167 | » » this.countOverlay.SetOptions(showLivePlayerPosition,·includeDeadBodies); |
| 140 | » » this.countOverlayAllowsMovement·=·allowedToMove; | 168 | » » this.countOverlayAllowsMovement·=·allowedToMove; |
| 141 | » » this.taskOverlay.Hide(); | 169 | » » this.taskOverlay.Hide(); |
| 142 | » » this.HerePoint.enabled·=·!showLivePlayerPosition; | 170 | » » this.HerePoint.enabled·=·!showLivePlayerPosition; |
| 171 | » » this.TrackedHerePoint.gameObject.SetActive(false); | ||
| 143 | » » if·(this.HerePoint.enabled) | 172 | » » if·(this.HerePoint.enabled) |
| 144 | » » { | 173 | » » { |
| 145 | » » » PlayerControl.LocalPlayer.SetPlayerMaterialColors(this.HerePoint); | 174 | » » » PlayerControl.LocalPlayer.SetPlayerMaterialColors(this.HerePoint); |
| 146 | » » } | 175 | » » } |
| 147 | » » DestroyableSingleton<HudManager>.Instance.SetHudActive(false); | 176 | » » DestroyableSingleton<HudManager>.Instance.SetHudActive(false); |
| 148 | » } | 177 | » } |
| 149 | 178 | ||
| Offset 162, 14 lines modified | Offset 191, 23 lines modified | ||
| 162 | » » { | 191 | » » { |
| 163 | » » » this.preMeetingPosition·=·null; | 192 | » » » this.preMeetingPosition·=·null; |
| 164 | » » } | 193 | » » } |
| 165 | » » vector·/=·ShipStatus.Instance.MapScale; | 194 | » » vector·/=·ShipStatus.Instance.MapScale; |
| 166 | » » vector.x·*=·Mathf.Sign(ShipStatus.Instance.transform.localScale.x); | 195 | » » vector.x·*=·Mathf.Sign(ShipStatus.Instance.transform.localScale.x); |
| 167 | » » vector.z·=·-1f; | 196 | » » vector.z·=·-1f; |
| 168 | » » this.HerePoint.transform.localPosition·=·vector; | 197 | » » this.HerePoint.transform.localPosition·=·vector; |
| 198 | » » if·(PlayerControl.LocalPlayer.isTrackingPlayer) | ||
| 199 | » » { | ||
| 200 | » » » this.trackedPointDelayTime·+=·Time.deltaTime; | ||
| 201 | » » » if·(this.trackedPointDelayTime·>=·GameManager.Instance.LogicOptions.GetTrackerDelay()) | ||
| 202 | » » » { | ||
| 203 | » » » » this.UpdateTrackedPosition(); | ||
| 204 | » » » » this.trackedPointDelayTime·=·0f; | ||
| 205 | » » » } | ||
| 206 | » » } | ||
| 169 | » } | 207 | » } |
| 170 | 208 | ||
| 171 | » private·void·Awake() | 209 | » private·void·Awake() |
| 172 | » { | 210 | » { |
| 173 | » » MapBehaviour.Instance·=·this; | 211 | » » MapBehaviour.Instance·=·this; |
| 174 | » » this.specialInputHandler·=·base.GetComponent<SpecialInputHandler>(); | 212 | » » this.specialInputHandler·=·base.GetComponent<SpecialInputHandler>(); |
| 175 | » } | 213 | » } |
| Offset 182, 31 lines modified | Offset 220, 67 lines modified | ||
| 182 | » » if·(Mathf.Sign(localScale.x)·!=·Mathf.Sign(ShipStatus.Instance.transform.localScale.x)) | 220 | » » if·(Mathf.Sign(localScale.x)·!=·Mathf.Sign(ShipStatus.Instance.transform.localScale.x)) |
| 183 | » » { | 221 | » » { |
| 184 | » » » localScale.x·*=·-1f; | 222 | » » » localScale.x·*=·-1f; |
| 185 | » » } | 223 | » » } |
| 186 | » » this.taskOverlay.transform.localScale·=·localScale; | 224 | » » this.taskOverlay.transform.localScale·=·localScale; |
| 187 | » » this.fadedBackground.SetActive(MeetingHud.Instance); | 225 | » » this.fadedBackground.SetActive(MeetingHud.Instance); |
| 188 | » » this.HerePoint.material.SetInt(PlayerMaterial.MaskLayer,·255); | 226 | » » this.HerePoint.material.SetInt(PlayerMaterial.MaskLayer,·255); |
| Max diff block lines reached; 1535/5680 bytes (27.02%) of diff not shown. | |||
| Offset 33, 15 lines modified | Offset 33, 15 lines modified | ||
| 33 | » » { | 33 | » » { |
| 34 | » » » this.Image.material.SetFloat("_Outline",·(float)(on·?·1·:·0)); | 34 | » » » this.Image.material.SetFloat("_Outline",·(float)(on·?·1·:·0)); |
| 35 | » » » this.Image.material.SetColor("_OutlineColor",·Color.white); | 35 | » » » this.Image.material.SetColor("_OutlineColor",·Color.white); |
| 36 | » » » this.Image.material.SetColor("_AddColor",·mainTarget·?·Color.white·:·Color.clear); | 36 | » » » this.Image.material.SetColor("_AddColor",·mainTarget·?·Color.white·:·Color.clear); |
| 37 | » » } | 37 | » » } |
| 38 | » } | 38 | » } |
| 39 | 39 | ||
| 40 | » public·float·CanUse( | 40 | » public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse) |
| 41 | » { | 41 | » { |
| 42 | » » float·num·=·float.MaxValue; | 42 | » » float·num·=·float.MaxValue; |
| 43 | » » PlayerControl·@object·=·pc.Object; | 43 | » » PlayerControl·@object·=·pc.Object; |
| 44 | » » couldUse·=·pc.Object.CanMove; | 44 | » » couldUse·=·pc.Object.CanMove; |
| 45 | » » canUse·=·couldUse; | 45 | » » canUse·=·couldUse; |
| 46 | » » if·(canUse) | 46 | » » if·(canUse) |
| 47 | » » { | 47 | » » { |
| Offset 8, 15 lines modified | Offset 8, 15 lines modified | ||
| 8 | { | 8 | { |
| 9 | » public·override·void·Begin(PlayerTask·task) | 9 | » public·override·void·Begin(PlayerTask·task) |
| 10 | » { | 10 | » { |
| 11 | » » base.Begin(task); | 11 | » » base.Begin(task); |
| 12 | » » this.medscan·=·ShipStatus.Instance.Systems[SystemTypes.MedBay]·as·MedScanSystem; | 12 | » » this.medscan·=·ShipStatus.Instance.Systems[SystemTypes.MedBay]·as·MedScanSystem; |
| 13 | » » this.gauge.Value·=·0f; | 13 | » » this.gauge.Value·=·0f; |
| 14 | » » base.transform.position·=·new·Vector3(100f,·0f,·0f); | 14 | » » base.transform.position·=·new·Vector3(100f,·0f,·0f); |
| 15 | » » | 15 | » » NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data; |
| 16 | » » int·playerId·=·(int)data.PlayerId; | 16 | » » int·playerId·=·(int)data.PlayerId; |
| 17 | » » string·colorName·=·Palette.GetColorName(data.DefaultOutfit.ColorId.Wrap(Palette.ColorNames.Length)); | 17 | » » string·colorName·=·Palette.GetColorName(data.DefaultOutfit.ColorId.Wrap(Palette.ColorNames.Length)); |
| 18 | » » StringBuilder·stringBuilder·=·new·StringBuilder(); | 18 | » » StringBuilder·stringBuilder·=·new·StringBuilder(); |
| 19 | » » stringBuilder.Append(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.MedID,·Array.Empty<object>())·+·"·"); | 19 | » » stringBuilder.Append(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.MedID,·Array.Empty<object>())·+·"·"); |
| 20 | » » string·text·=·colorName.ToUpperInvariant(); | 20 | » » string·text·=·colorName.ToUpperInvariant(); |
| 21 | » » if·(text.Length·>·3) | 21 | » » if·(text.Length·>·3) |
| 22 | » » { | 22 | » » { |
| Offset 79, 15 lines modified | Offset 79, 15 lines modified | ||
| 79 | » » if·(this.medscan.CurrentUser·!=·playerId) | 79 | » » if·(this.medscan.CurrentUser·!=·playerId) |
| 80 | » » { | 80 | » » { |
| 81 | » » » if·(this.medscan.CurrentUser·==·255) | 81 | » » » if·(this.medscan.CurrentUser·==·255) |
| 82 | » » » { | 82 | » » » { |
| 83 | » » » » this.text.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.MedscanRequested,·Array.Empty<object>()); | 83 | » » » » this.text.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.MedscanRequested,·Array.Empty<object>()); |
| 84 | » » » » return; | 84 | » » » » return; |
| 85 | » » » } | 85 | » » » } |
| 86 | » » » | 86 | » » » NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(this.medscan.CurrentUser); |
| 87 | » » » this.text.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.MedscanWaitingFor,·new·object[]·{·playerById.PlayerName·}); | 87 | » » » this.text.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.MedscanWaitingFor,·new·object[]·{·playerById.PlayerName·}); |
| 88 | » » » return; | 88 | » » » return; |
| 89 | » » } | 89 | » » } |
| 90 | » » else | 90 | » » else |
| 91 | » » { | 91 | » » { |
| 92 | » » » if·(this.state·!=·MedScanMinigame.PositionState.WalkingToPad) | 92 | » » » if·(this.state·!=·MedScanMinigame.PositionState.WalkingToPad) |
| 93 | » » » { | 93 | » » » { |
| Offset 1, 16 lines modified | Offset 1, 16 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections; | 2 | using·System.Collections; |
| 3 | using·UnityEngine; | 3 | using·UnityEngine; |
| 4 | 4 | ||
| 5 | public·class·MeetingCalledAnimation·:·OverlayAnimation | 5 | public·class·MeetingCalledAnimation·:·OverlayAnimation |
| 6 | { | 6 | { |
| 7 | » public·void·Initialize( | 7 | » public·void·Initialize(NetworkedPlayerInfo.PlayerOutfit·outfit) |
| 8 | » { | 8 | » { |
| 9 | » » this.playerParts.UpdateFrom | 9 | » » this.playerParts.UpdateFromPlayerOutfit(outfit,·PlayerMaterial.MaskType.None,·false,·false,·null,·false); |
| 10 | » } | 10 | » } |
| 11 | 11 | ||
| 12 | » public·override·IEnumerator·CoShow(KillOverlay·parent) | 12 | » public·override·IEnumerator·CoShow(KillOverlay·parent) |
| 13 | » { | 13 | » { |
| 14 | » » base.gameObject.SetActive(true); | 14 | » » base.gameObject.SetActive(true); |
| 15 | » » if·(Constants.ShouldPlaySfx()) | 15 | » » if·(Constants.ShouldPlaySfx()) |
| 16 | » » { | 16 | » » { |
| Offset 28, 15 lines modified | Offset 28, 15 lines modified | ||
| 28 | » » } | 28 | » » } |
| 29 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpcImmediately(this.NetId,·24,·SendOption.Reliable,·AmongUsClient.Instance.HostId); | 29 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpcImmediately(this.NetId,·24,·SendOption.Reliable,·AmongUsClient.Instance.HostId); |
| 30 | » » messageWriter.Write(playerId); | 30 | » » messageWriter.Write(playerId); |
| 31 | » » messageWriter.Write(suspectIdx); | 31 | » » messageWriter.Write(suspectIdx); |
| 32 | » » AmongUsClient.Instance.FinishRpcImmediately(messageWriter); | 32 | » » AmongUsClient.Instance.FinishRpcImmediately(messageWriter); |
| 33 | » } | 33 | » } |
| 34 | 34 | ||
| 35 | » private·void·RpcVotingComplete(MeetingHud.VoterState[]·states,· | 35 | » private·void·RpcVotingComplete(MeetingHud.VoterState[]·states,·NetworkedPlayerInfo·exiled,·bool·tie) |
| 36 | » { | 36 | » { |
| 37 | » » if·(AmongUsClient.Instance.AmClient) | 37 | » » if·(AmongUsClient.Instance.AmClient) |
| 38 | » » { | 38 | » » { |
| 39 | » » » this.VotingComplete(states,·exiled,·tie); | 39 | » » » this.VotingComplete(states,·exiled,·tie); |
| 40 | » » } | 40 | » » } |
| 41 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·23,·SendOption.Reliable); | 41 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·23,·SendOption.Reliable); |
| 42 | » » messageWriter.WritePacked(states.Length); | 42 | » » messageWriter.WritePacked(states.Length); |
| Offset 66, 15 lines modified | Offset 66, 18 lines modified | ||
| 66 | » » for·(int·i·=·0;·i·<·this.playerStates.Length;·i++) | 66 | » » for·(int·i·=·0;·i·<·this.playerStates.Length;·i++) |
| 67 | » » { | 67 | » » { |
| 68 | » » » PlayerVoteArea·playerVoteArea·=·this.playerStates[i]; | 68 | » » » PlayerVoteArea·playerVoteArea·=·this.playerStates[i]; |
| 69 | » » » writer.StartMessage(playerVoteArea.TargetPlayerId); | 69 | » » » writer.StartMessage(playerVoteArea.TargetPlayerId); |
| 70 | » » » this.playerStates[i].Serialize(writer); | 70 | » » » this.playerStates[i].Serialize(writer); |
| 71 | » » » writer.EndMessage(); | 71 | » » » writer.EndMessage(); |
| 72 | » » } | 72 | » » } |
| 73 | » » if·(!initialState) | ||
| 74 | » » { | ||
| 73 | » » base.ClearDirtyBits(); | 75 | » » » base.ClearDirtyBits(); |
| 76 | » » } | ||
| 74 | » » return·true; | 77 | » » return·true; |
| 75 | » } | 78 | » } |
| 76 | 79 | ||
| 77 | » public·override·void·Deserialize(MessageReader·reader,·bool·initialState) | 80 | » public·override·void·Deserialize(MessageReader·reader,·bool·initialState) |
| 78 | » { | 81 | » { |
| 79 | » » if·(initialState) | 82 | » » if·(initialState) |
| 80 | » » { | 83 | » » { |
| Offset 106, 15 lines modified | Offset 109, 15 lines modified | ||
| 106 | » » case·23: | 109 | » » case·23: |
| 107 | » » { | 110 | » » { |
| 108 | » » » MeetingHud.VoterState[]·array·=·new·MeetingHud.VoterState[reader.ReadPackedInt32()]; | 111 | » » » MeetingHud.VoterState[]·array·=·new·MeetingHud.VoterState[reader.ReadPackedInt32()]; |
| 109 | » » » for·(int·i·=·0;·i·<·array.Length;·i++) | 112 | » » » for·(int·i·=·0;·i·<·array.Length;·i++) |
| 110 | » » » { | 113 | » » » { |
| 111 | » » » » array[i]·=·MeetingHud.VoterState.Deserialize(reader); | 114 | » » » » array[i]·=·MeetingHud.VoterState.Deserialize(reader); |
| 112 | » » » } | 115 | » » » } |
| 113 | » » » | 116 | » » » NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(reader.ReadByte()); |
| 114 | » » » bool·flag·=·reader.ReadBoolean(); | 117 | » » » bool·flag·=·reader.ReadBoolean(); |
| 115 | » » » this.VotingComplete(array,·playerById,·flag); | 118 | » » » this.VotingComplete(array,·playerById,·flag); |
| 116 | » » » return; | 119 | » » » return; |
| 117 | » » } | 120 | » » } |
| 118 | » » case·24: | 121 | » » case·24: |
| 119 | » » { | 122 | » » { |
| 120 | » » » byte·b·=·reader.ReadByte(); | 123 | » » » byte·b·=·reader.ReadByte(); |
| Offset 126, 14 lines modified | Offset 129, 22 lines modified | ||
| 126 | » » » this.ClearVote(); | 129 | » » » this.ClearVote(); |
| 127 | » » » return; | 130 | » » » return; |
| 128 | » » default: | 131 | » » default: |
| 129 | » » » return; | 132 | » » » return; |
| 130 | » » } | 133 | » » } |
| 131 | » } | 134 | » } |
| 132 | 135 | ||
| 136 | » public·bool·IsPersistent | ||
| 137 | » { | ||
| 138 | » » get | ||
| 139 | » » { | ||
| 140 | » » » return·false; | ||
| 141 | » » } | ||
| 142 | » } | ||
| 143 | |||
| 133 | » public·MeetingHud.VoteStates·CurrentState | 144 | » public·MeetingHud.VoteStates·CurrentState |
| 134 | » { | 145 | » { |
| 135 | » » get | 146 | » » get |
| 136 | » » { | 147 | » » { |
| 137 | » » » return·this.state; | 148 | » » » return·this.state; |
| 138 | » » } | 149 | » » } |
| 139 | » } | 150 | » } |
| Offset 289, 26 lines modified | Offset 300, 26 lines modified | ||
| 289 | » » SpriteRenderer[]·outerMasks·=·this.OuterMasks; | 300 | » » SpriteRenderer[]·outerMasks·=·this.OuterMasks; |
| 290 | » » for·(int·i·=·0;·i·<·outerMasks.Length;·i++) | 301 | » » for·(int·i·=·0;·i·<·outerMasks.Length;·i++) |
| 291 | » » { | 302 | » » { |
| 292 | » » » outerMasks[i].enabled·=·enabled; | 303 | » » » outerMasks[i].enabled·=·enabled; |
| 293 | » » } | 304 | » » } |
| 294 | » } | 305 | » } |
| 295 | 306 | ||
| 296 | » public·IEnumerator·CoIntro( | 307 | » public·IEnumerator·CoIntro(NetworkedPlayerInfo·reporter,·NetworkedPlayerInfo·reportedBody,·NetworkedPlayerInfo[]·deadBodies) |
| 297 | » { | 308 | » { |
| 298 | » » this.SkipVoteButton.SetDisabled(); | 309 | » » this.SkipVoteButton.SetDisabled(); |
| 299 | » » base.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform); | 310 | » » base.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform); |
| 300 | » » base.transform.localPosition·=·Vector3.zero; | 311 | » » base.transform.localPosition·=·Vector3.zero; |
| 301 | » » this.meetingContents.localPosition·=·new·Vector3(0f,·-10f,·0f); | 312 | » » this.meetingContents.localPosition·=·new·Vector3(0f,·-10f,·0f); |
| 302 | » » DestroyableSingleton<HudManager>.Instance.Chat.ForceClosed(); | 313 | » » DestroyableSingleton<HudManager>.Instance.Chat.ForceClosed(); |
| 303 | » » DestroyableSingleton<HudManager>.Instance.SetHudActive(false); | 314 | » » DestroyableSingleton<HudManager>.Instance.SetHudActive(false); |
| 304 | » » bool·flag·=·reportedBody·==·null; | 315 | » » bool·flag·=·reportedBody·==·null; |
| 305 | » » MeetingCalledAnimation·meetingCalledAnimation·=·(flag·?·ShipStatus.Instance.EmergencyOverlay·:·ShipStatus.Instance.ReportOverlay); | 316 | » » MeetingCalledAnimation·meetingCalledAnimation·=·(flag·?·ShipStatus.Instance.EmergencyOverlay·:·ShipStatus.Instance.ReportOverlay); |
| 306 | » » | 317 | » » NetworkedPlayerInfo·networkedPlayerInfo·=·(flag·?·reporter·:·reportedBody); |
| 307 | » » DestroyableSingleton<HudManager>.Instance.KillOverlay.ShowMeeting(meetingCalledAnimation,· | 318 | » » DestroyableSingleton<HudManager>.Instance.KillOverlay.ShowMeeting(meetingCalledAnimation,·networkedPlayerInfo.DefaultOutfit); |
| 308 | » » yield·return·DestroyableSingleton<HudManager>.Instance.KillOverlay.WaitForFinish(); | 319 | » » yield·return·DestroyableSingleton<HudManager>.Instance.KillOverlay.WaitForFinish(); |
| 309 | » » this.MeetingIntro.Init(reporter,·deadBodies); | 320 | » » this.MeetingIntro.Init(reporter,·deadBodies); |
| 310 | » » this.SetMasksEnabled(true); | 321 | » » this.SetMasksEnabled(true); |
| 311 | » » yield·return·Effects.Slide2D(this.meetingContents,·new·Vector2(0f,·-10f),·new·Vector2(0f,·0f),·0.25f); | 322 | » » yield·return·Effects.Slide2D(this.meetingContents,·new·Vector2(0f,·-10f),·new·Vector2(0f,·0f),·0.25f); |
| 312 | » » yield·return·Effects.Wait(0.5f); | 323 | » » yield·return·Effects.Wait(0.5f); |
| 313 | » » yield·return·this.MeetingIntro.CoRun(); | 324 | » » yield·return·this.MeetingIntro.CoRun(); |
| 314 | » » this.SetMasksEnabled(false); | 325 | » » this.SetMasksEnabled(false); |
| Offset 322, 15 lines modified | Offset 333, 15 lines modified | ||
| 322 | » private·IEnumerator·CoStartCutscene() | 333 | » private·IEnumerator·CoStartCutscene() |
| 323 | » { | 334 | » { |
| 324 | » » ConsoleJoystick.SetMode_Task(); | 335 | » » ConsoleJoystick.SetMode_Task(); |
| 325 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·1f,·false); | 336 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·1f,·false); |
| 326 | » » ExileController·exileController·=·Object.Instantiate<ExileController>(ShipStatus.Instance.ExileCutscenePrefab); | 337 | » » ExileController·exileController·=·Object.Instantiate<ExileController>(ShipStatus.Instance.ExileCutscenePrefab); |
| 327 | » » exileController.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform,·false); | 338 | » » exileController.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform,·false); |
| 328 | » » exileController.transform.localPosition·=·new·Vector3(0f,·0f,·-60f); | 339 | » » exileController.transform.localPosition·=·new·Vector3(0f,·0f,·-60f); |
| 329 | » » exileController.Begin(this.exiledPlayer,·this.wasTie); | 340 | » » exileController.BeginForGameplay(this.exiledPlayer,·this.wasTie); |
| 330 | » » this.DespawnOnDestroy·=·false; | 341 | » » this.DespawnOnDestroy·=·false; |
| 331 | » » if·(MapBehaviour.Instance) | 342 | » » if·(MapBehaviour.Instance) |
| 332 | » » { | 343 | » » { |
| 333 | » » » MapBehaviour.Instance.Close(); | 344 | » » » MapBehaviour.Instance.Close(); |
| 334 | » » } | 345 | » » } |
| 335 | » » Object.Destroy(base.gameObject); | 346 | » » Object.Destroy(base.gameObject); |
| 336 | » » yield·break; | 347 | » » yield·break; |
| Offset 340, 21 lines modified | Offset 351, 21 lines modified | ||
| 340 | » { | 351 | » { |
| 341 | » » this.reporterId·=·reporter; | 352 | » » this.reporterId·=·reporter; |
| 342 | » » this.PopulateButtons(reporter); | 353 | » » this.PopulateButtons(reporter); |
| 343 | » } | 354 | » } |
| 344 | 355 | ||
| 345 | » public·void·Close() | 356 | » public·void·Close() |
| 346 | » { | 357 | » { |
| 347 | » » | 358 | » » NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data; |
| 348 | » » DestroyableSingleton<HudManager>.Instance.Chat.SetVisible(data.IsDead); | 359 | » » DestroyableSingleton<HudManager>.Instance.Chat.SetVisible(data.IsDead); |
| 349 | » » DestroyableSingleton<HudManager>.Instance.Chat.HideBanButton(); | 360 | » » DestroyableSingleton<HudManager>.Instance.Chat.HideBanButton(); |
| Max diff block lines reached; 10143/15307 bytes (66.26%) of diff not shown. | |||
| Offset 13, 15 lines modified | Offset 13, 15 lines modified | ||
| 13 | » » SpriteRenderer[]·outsideMasks·=·this.OutsideMasks; | 13 | » » SpriteRenderer[]·outsideMasks·=·this.OutsideMasks; |
| 14 | » » for·(int·i·=·0;·i·<·outsideMasks.Length;·i++) | 14 | » » for·(int·i·=·0;·i·<·outsideMasks.Length;·i++) |
| 15 | » » { | 15 | » » { |
| 16 | » » » outsideMasks[i].material.SetInt(PlayerMaterial.MaskLayer,·254); | 16 | » » » outsideMasks[i].material.SetInt(PlayerMaterial.MaskLayer,·254); |
| 17 | » » } | 17 | » » } |
| 18 | » } | 18 | » } |
| 19 | 19 | ||
| 20 | » public·void·Init( | 20 | » public·void·Init(NetworkedPlayerInfo·reporter,·NetworkedPlayerInfo[]·deadBodies) |
| 21 | » { | 21 | » { |
| 22 | » » PlayerVoteArea·playerVoteArea·=·Object.Instantiate<PlayerVoteArea>(this.VoteAreaPrefab,·this.OverlayParent); | 22 | » » PlayerVoteArea·playerVoteArea·=·Object.Instantiate<PlayerVoteArea>(this.VoteAreaPrefab,·this.OverlayParent); |
| 23 | » » playerVoteArea.transform.localPosition·=·this.ReporterPos; | 23 | » » playerVoteArea.transform.localPosition·=·this.ReporterPos; |
| 24 | » » playerVoteArea.SetMaskLayer(0); | 24 | » » playerVoteArea.SetMaskLayer(0); |
| 25 | » » playerVoteArea.SetCosmetics(reporter); | 25 | » » playerVoteArea.SetCosmetics(reporter); |
| 26 | » » playerVoteArea.SetDead(true,·false,·false); | 26 | » » playerVoteArea.SetDead(true,·false,·false); |
| 27 | » » float·num·=·this.background.size.x·/·2f; | 27 | » » float·num·=·this.background.size.x·/·2f; |
| Offset 1, 12 lines modified | Offset 1, 20 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | 2 | ||
| 3 | public·class·MeetingRoomManager·:·IDisconnectHandler | 3 | public·class·MeetingRoomManager·:·IDisconnectHandler |
| 4 | { | 4 | { |
| 5 | » public·bool·IsPersistent | ||
| 6 | » { | ||
| 7 | » » get | ||
| 8 | » » { | ||
| 9 | » » » return·false; | ||
| 10 | » » } | ||
| 11 | » } | ||
| 12 | |||
| 5 | » public·void·AssignSelf(PlayerControl·reporter,· | 13 | » public·void·AssignSelf(PlayerControl·reporter,·NetworkedPlayerInfo·target) |
| 6 | » { | 14 | » { |
| 7 | » » this.reporter·=·reporter; | 15 | » » this.reporter·=·reporter; |
| 8 | » » this.target·=·target; | 16 | » » this.target·=·target; |
| 9 | » » AmongUsClient.Instance.DisconnectHandlers.AddUnique(this); | 17 | » » AmongUsClient.Instance.DisconnectHandlers.AddUnique(this); |
| 10 | » } | 18 | » } |
| 11 | 19 | ||
| 12 | » public·void·RemoveSelf() | 20 | » public·void·RemoveSelf() |
| Offset 27, 9 lines modified | Offset 35, 9 lines modified | ||
| 27 | » » this.HandleDisconnect(null,·DisconnectReasons.Unknown); | 35 | » » this.HandleDisconnect(null,·DisconnectReasons.Unknown); |
| 28 | » } | 36 | » } |
| 29 | 37 | ||
| 30 | » public·static·readonly·MeetingRoomManager·Instance·=·new·MeetingRoomManager(); | 38 | » public·static·readonly·MeetingRoomManager·Instance·=·new·MeetingRoomManager(); |
| 31 | 39 | ||
| 32 | » private·PlayerControl·reporter; | 40 | » private·PlayerControl·reporter; |
| 33 | 41 | ||
| 34 | » private· | 42 | » private·NetworkedPlayerInfo·target; |
| 35 | } | 43 | } |
| Offset 336, 36 lines modified | Offset 336, 36 lines modified | ||
| 336 | 336 | ||
| 337 | » private·const·int·ORE_NUMBER·=·3; | 337 | » private·const·int·ORE_NUMBER·=·3; |
| 338 | 338 | ||
| 339 | » private·const·int·MAX_GOOD_ROCKS·=·2; | 339 | » private·const·int·MAX_GOOD_ROCKS·=·2; |
| 340 | 340 | ||
| 341 | » private·const·int·MAX_PERFECT_ROCKS·=·4; | 341 | » private·const·int·MAX_PERFECT_ROCKS·=·4; |
| 342 | 342 | ||
| 343 | » [Tooltip("Speed·of·power·meter·when·breaking·rocks")] | ||
| 344 | » [SerializeField] | 343 | » [SerializeField] |
| 344 | » [Tooltip("Speed·of·power·meter·when·breaking·rocks")] | ||
| 345 | » private·float·powerBarSpeed·=·1f; | 345 | » private·float·powerBarSpeed·=·1f; |
| 346 | 346 | ||
| 347 | » [SerializeField] | 347 | » [SerializeField] |
| 348 | » [Tooltip("angle·of·pickaxe·while·animating·breaking·a·rock")] | 348 | » [Tooltip("angle·of·pickaxe·while·animating·breaking·a·rock")] |
| 349 | » private·float·pikeaxeFirstAngle·=·-90f; | 349 | » private·float·pikeaxeFirstAngle·=·-90f; |
| 350 | 350 | ||
| 351 | » [Tooltip("angle·of·pickaxe·while·animating·breaking·a·rock")] | ||
| 352 | » [SerializeField] | 351 | » [SerializeField] |
| 352 | » [Tooltip("angle·of·pickaxe·while·animating·breaking·a·rock")] | ||
| 353 | » private·float·pikeaxeSecondAngle·=·50f; | 353 | » private·float·pikeaxeSecondAngle·=·50f; |
| 354 | 354 | ||
| 355 | » [Tooltip("time·of·pickeaxe·animation·in·seconds")] | 355 | » [Tooltip("time·of·pickeaxe·animation·in·seconds")] |
| 356 | » [SerializeField] | 356 | » [SerializeField] |
| 357 | » private·float·pikeaxeAnimTime·=·0.3f; | 357 | » private·float·pikeaxeAnimTime·=·0.3f; |
| 358 | 358 | ||
| 359 | » [SerializeField] | ||
| 360 | » [Tooltip("Good·Zone·percentage·max·value")] | 359 | » [Tooltip("Good·Zone·percentage·max·value")] |
| 360 | » [SerializeField] | ||
| 361 | » private·float·goodPercentage·=·0.5f; | 361 | » private·float·goodPercentage·=·0.5f; |
| 362 | 362 | ||
| 363 | » [SerializeField] | ||
| 364 | » [Tooltip("Great·Zone·percentage·max·value")] | 363 | » [Tooltip("Great·Zone·percentage·max·value")] |
| 364 | » [SerializeField] | ||
| 365 | » private·float·greatPercentage·=·0.8f; | 365 | » private·float·greatPercentage·=·0.8f; |
| 366 | 366 | ||
| 367 | » [SerializeField] | 367 | » [SerializeField] |
| 368 | » private·Collider2D·pickaxe; | 368 | » private·Collider2D·pickaxe; |
| 369 | 369 | ||
| 370 | » [SerializeField] | 370 | » [SerializeField] |
| 371 | » private·GameObject·pickaxeSprite; | 371 | » private·GameObject·pickaxeSprite; |
| Offset 375, 16 lines modified | Offset 375, 16 lines modified | ||
| 375 | 375 | ||
| 376 | » [SerializeField] | 376 | » [SerializeField] |
| 377 | » private·PowerBarMining·powerBarMining; | 377 | » private·PowerBarMining·powerBarMining; |
| 378 | 378 | ||
| 379 | » [SerializeField] | 379 | » [SerializeField] |
| 380 | » private·List<CollectableOre>·ores; | 380 | » private·List<CollectableOre>·ores; |
| 381 | 381 | ||
| 382 | » [Header("Audio·Files")] | ||
| 383 | » [SerializeField] | 382 | » [SerializeField] |
| 383 | » [Header("Audio·Files")] | ||
| 384 | » private·AudioClip[]·rockHitWeak; | 384 | » private·AudioClip[]·rockHitWeak; |
| 385 | 385 | ||
| 386 | » [SerializeField] | 386 | » [SerializeField] |
| 387 | » private·AudioClip[]·rockHitStrong; | 387 | » private·AudioClip[]·rockHitStrong; |
| 388 | 388 | ||
| 389 | » [SerializeField] | 389 | » [SerializeField] |
| 390 | » private·AudioClip[]·rockRelease; | 390 | » private·AudioClip[]·rockRelease; |
| Offset 112, 15 lines modified | Offset 112, 15 lines modified | ||
| 112 | » » » if·(PlayerControl.LocalPlayer) | 112 | » » » if·(PlayerControl.LocalPlayer) |
| 113 | » » » { | 113 | » » » { |
| 114 | » » » » PlayerControl.HideCursorTemporarily(); | 114 | » » » » PlayerControl.HideCursorTemporarily(); |
| 115 | » » » } | 115 | » » » } |
| 116 | » » » this.amClosing·=·Minigame.CloseState.Closing; | 116 | » » » this.amClosing·=·Minigame.CloseState.Closing; |
| 117 | » » » this.logger.Info("Closing·minigame·"·+·base.GetType().Name,·null); | 117 | » » » this.logger.Info("Closing·minigame·"·+·base.GetType().Name,·null); |
| 118 | » » » IAnalyticsReporter·analytics·=·DestroyableSingleton<DebugAnalytics>.Instance.Analytics; | 118 | » » » IAnalyticsReporter·analytics·=·DestroyableSingleton<DebugAnalytics>.Instance.Analytics; |
| 119 | » » » | 119 | » » » NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data; |
| 120 | » » » TaskTypes·taskType·=·this.TaskType; | 120 | » » » TaskTypes·taskType·=·this.TaskType; |
| 121 | » » » float·num·=·Time.realtimeSinceStartup·-·this.timeOpened; | 121 | » » » float·num·=·Time.realtimeSinceStartup·-·this.timeOpened; |
| 122 | » » » PlayerTask·myTask·=·this.MyTask; | 122 | » » » PlayerTask·myTask·=·this.MyTask; |
| 123 | » » » analytics.MinigameClosed(data,·taskType,·num,·myTask·!=·null·&&·myTask.IsComplete); | 123 | » » » analytics.MinigameClosed(data,·taskType,·num,·myTask·!=·null·&&·myTask.IsComplete); |
| 124 | » » » base.StartCoroutine(this.CoDestroySelf()); | 124 | » » » base.StartCoroutine(this.CoDestroySelf()); |
| 125 | » » » return; | 125 | » » » return; |
| 126 | » » } | 126 | » » } |
| Offset 2, 33 lines modified | Offset 2, 43 lines modified | ||
| 2 | using·System.Collections; | 2 | using·System.Collections; |
| 3 | using·UnityEngine; | 3 | using·UnityEngine; |
| 4 | 4 | ||
| 5 | public·class·MiraExileController·:·ExileController | 5 | public·class·MiraExileController·:·ExileController |
| 6 | { | 6 | { |
| 7 | » protected·override·IEnumerator·Animate() | 7 | » protected·override·IEnumerator·Animate() |
| 8 | » { | 8 | » { |
| 9 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | ||
| 10 | » » { | ||
| 9 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false); | 11 | » » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false); |
| 12 | » » } | ||
| 10 | » » yield·return·Effects.All(new·IEnumerator[] | 13 | » » yield·return·Effects.All(new·IEnumerator[] |
| 11 | » » { | 14 | » » { |
| 12 | » » » this.PlayerSpin(), | 15 | » » » this.PlayerSpin(), |
| 13 | » » » this.HandleText(this.Duration·*·0.5f,·this.Duration·*·0.5f), | 16 | » » » this.HandleText(this.Duration·*·0.5f,·this.Duration·*·0.5f), |
| 14 | » » » Effects.Slide2D(this.BackgroundClouds,·new·Vector2(0f,·-3f),·new·Vector2(0f,·0.5f),·this.Duration), | 17 | » » » Effects.Slide2D(this.BackgroundClouds,·new·Vector2(0f,·-3f),·new·Vector2(0f,·0.5f),·this.Duration), |
| 15 | » » » Effects.Sequence(new·IEnumerator[] | 18 | » » » Effects.Sequence(new·IEnumerator[] |
| 16 | » » » { | 19 | » » » { |
| 17 | » » » » Effects.Wait(2f), | 20 | » » » » Effects.Wait(2f), |
| 18 | » » » » Effects.Slide2D(this.ForegroundClouds,·new·Vector2(0f,·-7f),·new·Vector2(0f,·2.5f),·0.75f) | 21 | » » » » Effects.Slide2D(this.ForegroundClouds,·new·Vector2(0f,·-7f),·new·Vector2(0f,·2.5f),·0.75f) |
| 19 | » » » }) | 22 | » » » }) |
| 20 | » » }); | 23 | » » }); |
| 21 | » » if·( | 24 | » » if·(this.initData.confirmImpostor) |
| 22 | » » { | 25 | » » { |
| 23 | » » » this.ImpostorText.gameObject.SetActive(true); | 26 | » » » this.ImpostorText.gameObject.SetActive(true); |
| 24 | » » } | 27 | » » } |
| 25 | » » yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f); | 28 | » » yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f); |
| 26 | » » yield·return·new·WaitForSeconds(0.5f); | 29 | » » yield·return·new·WaitForSeconds(0.5f); |
| 30 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | ||
| 31 | » » { | ||
| 27 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false); | 32 | » » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false); |
| 33 | » » } | ||
| 34 | » » else | ||
| 35 | » » { | ||
| 36 | » » » yield·return·Effects.Wait(0.2f); | ||
| 37 | » » } | ||
| 28 | » » base.WrapUp(); | 38 | » » base.WrapUp(); |
| 29 | » » yield·break; | 39 | » » yield·break; |
| 30 | » } | 40 | » } |
| 31 | 41 | ||
| 32 | » private·IEnumerator·PlayerSpin() | 42 | » private·IEnumerator·PlayerSpin() |
| 33 | » { | 43 | » { |
| 34 | » » float·num·=·Camera.main.orthographicSize·+·1f; | 44 | » » float·num·=·Camera.main.orthographicSize·+·1f; |
| Offset 116, 15 lines modified | Offset 116, 15 lines modified | ||
| 116 | » » if·(!PlayerControl.LocalPlayer) | 116 | » » if·(!PlayerControl.LocalPlayer) |
| 117 | » » { | 117 | » » { |
| 118 | » » » source.volume·=·0f; | 118 | » » » source.volume·=·0f; |
| 119 | » » » return; | 119 | » » » return; |
| 120 | » » } | 120 | » » } |
| 121 | » » source.volume·=·1f; | 121 | » » source.volume·=·1f; |
| 122 | » » Vector2·truePosition·=·PlayerControl.LocalPlayer.GetTruePosition(); | 122 | » » Vector2·truePosition·=·PlayerControl.LocalPlayer.GetTruePosition(); |
| 123 | » » source.volume·=·SoundManager.GetSoundVolume(base.transform.position,·truePosition,·2f,·6f); | 123 | » » source.volume·=·SoundManager.GetSoundVolume(base.transform.position,·truePosition,·2f,·6f,·0f); |
| 124 | » } | 124 | » } |
| 125 | 125 | ||
| 126 | » private·const·float·TRIGGER_WAIT_TIME·=·0.5f; | 126 | » private·const·float·TRIGGER_WAIT_TIME·=·0.5f; |
| 127 | 127 | ||
| 128 | » private·const·string·SFX_ACTIVATE_NAME·=·"SporeActivate"; | 128 | » private·const·string·SFX_ACTIVATE_NAME·=·"SporeActivate"; |
| 129 | 129 | ||
| 130 | » private·const·string·SFX_SPAWN_NAME·=·"MushroomSpawn"; | 130 | » private·const·string·SFX_SPAWN_NAME·=·"MushroomSpawn"; |
| Offset 145, 63 lines modified | Offset 145, 63 lines modified | ||
| 145 | 145 | ||
| 146 | » [SerializeField] | 146 | » [SerializeField] |
| 147 | » private·SpriteRenderer·spores; | 147 | » private·SpriteRenderer·spores; |
| 148 | 148 | ||
| 149 | » [SerializeField] | 149 | » [SerializeField] |
| 150 | » private·GameObject·sporeMask; | 150 | » private·GameObject·sporeMask; |
| 151 | 151 | ||
| 152 | » [SerializeField] | ||
| 153 | » [Tooltip("Use·Fix·Mushroom·IDs·to·auto-set·this·value·for·all·mushrooms·on·the·map.")] | 152 | » [Tooltip("Use·Fix·Mushroom·IDs·to·auto-set·this·value·for·all·mushrooms·on·the·map.")] |
| 153 | » [SerializeField] | ||
| 154 | » [Header("Metadata")] | 154 | » [Header("Metadata")] |
| 155 | » private·int·id; | 155 | » private·int·id; |
| 156 | 156 | ||
| 157 | » [SerializeField] | ||
| 158 | » [Header("Mushroom·Animations")] | 157 | » [Header("Mushroom·Animations")] |
| 158 | » [SerializeField] | ||
| 159 | » private·SpriteAnim·mushroomAnimator; | 159 | » private·SpriteAnim·mushroomAnimator; |
| 160 | 160 | ||
| 161 | » [SerializeField] | 161 | » [SerializeField] |
| 162 | » private·AnimationClip·mushroomIdle; | 162 | » private·AnimationClip·mushroomIdle; |
| 163 | 163 | ||
| 164 | » [SerializeField] | 164 | » [SerializeField] |
| 165 | » private·AnimationClip·mushroomAppear; | 165 | » private·AnimationClip·mushroomAppear; |
| 166 | 166 | ||
| 167 | » [SerializeField] | 167 | » [SerializeField] |
| 168 | » private·AnimationClip·mushroomSteppedOn; | 168 | » private·AnimationClip·mushroomSteppedOn; |
| 169 | 169 | ||
| 170 | » [SerializeField] | ||
| 171 | » [Header("Spore·Cloud·Animations")] | 170 | » [Header("Spore·Cloud·Animations")] |
| 171 | » [SerializeField] | ||
| 172 | » private·SpriteAnim·sporeCloudAnimator; | 172 | » private·SpriteAnim·sporeCloudAnimator; |
| 173 | 173 | ||
| 174 | » [SerializeField] | 174 | » [SerializeField] |
| 175 | » private·SpriteAnim·sporeCloudMaskAnimator; | 175 | » private·SpriteAnim·sporeCloudMaskAnimator; |
| 176 | 176 | ||
| 177 | » [SerializeField] | 177 | » [SerializeField] |
| 178 | » private·AnimationClip·sporeCloudIdle; | 178 | » private·AnimationClip·sporeCloudIdle; |
| 179 | 179 | ||
| 180 | » [SerializeField] | 180 | » [SerializeField] |
| 181 | » private·AnimationClip·sporeCloudAppear; | 181 | » private·AnimationClip·sporeCloudAppear; |
| 182 | 182 | ||
| 183 | » [SerializeField] | 183 | » [SerializeField] |
| 184 | » private·AnimationClip·sporeCloudDisappear; | 184 | » private·AnimationClip·sporeCloudDisappear; |
| 185 | 185 | ||
| 186 | » [SerializeField] | ||
| 187 | » [Header("Timings")] | 186 | » [Header("Timings")] |
| 187 | » [SerializeField] | ||
| 188 | » private·float·secondsBetweenSporeReleases·=·17f; | 188 | » private·float·secondsBetweenSporeReleases·=·17f; |
| 189 | 189 | ||
| 190 | » [SerializeField] | 190 | » [SerializeField] |
| 191 | » private·float·secondsSporeIsActive·=·5f; | 191 | » private·float·secondsSporeIsActive·=·5f; |
| 192 | 192 | ||
| 193 | » [SerializeField] | 193 | » [SerializeField] |
| 194 | » private·float·secondsSporeReappearsFor·=·2f; | 194 | » private·float·secondsSporeReappearsFor·=·2f; |
| 195 | 195 | ||
| 196 | » [SerializeField] | 196 | » [SerializeField] |
| 197 | » private·float·secondsSporeFade·=·1f; | 197 | » private·float·secondsSporeFade·=·1f; |
| 198 | 198 | ||
| 199 | » [SerializeField] | ||
| 200 | » [Header("Audio")] | 199 | » [Header("Audio")] |
| 200 | » [SerializeField] | ||
| 201 | » private·AudioClip·spawnSound; | 201 | » private·AudioClip·spawnSound; |
| 202 | 202 | ||
| 203 | » [SerializeField] | 203 | » [SerializeField] |
| 204 | » private·AudioClip·activateSporeSound; | 204 | » private·AudioClip·activateSporeSound; |
| 205 | 205 | ||
| 206 | » private·ContactFilter2D·filter; | 206 | » private·ContactFilter2D·filter; |
| 207 | 207 | ||
| Offset 127, 16 lines modified | Offset 127, 16 lines modified | ||
| 127 | 127 | ||
| 128 | » [SerializeField] | 128 | » [SerializeField] |
| 129 | » private·SpriteRenderer·sprite; | 129 | » private·SpriteRenderer·sprite; |
| 130 | 130 | ||
| 131 | » [SerializeField] | 131 | » [SerializeField] |
| 132 | » private·ParticleSystem·whackedEffect; | 132 | » private·ParticleSystem·whackedEffect; |
| 133 | 133 | ||
| 134 | » [SerializeField] | ||
| 135 | » [Header("Audio")] | 134 | » [Header("Audio")] |
| 135 | » [SerializeField] | ||
| 136 | » private·AudioClip·mushroomAppearSFX; | 136 | » private·AudioClip·mushroomAppearSFX; |
| 137 | 137 | ||
| 138 | » [SerializeField] | 138 | » [SerializeField] |
| 139 | » private·AudioClip·mushroomDisappearSFX; | 139 | » private·AudioClip·mushroomDisappearSFX; |
| 140 | 140 | ||
| 141 | » [SerializeField] | 141 | » [SerializeField] |
| 142 | » private·AudioClip·mushroomHitSFX; | 142 | » private·AudioClip·mushroomHitSFX; |
| Offset 33, 15 lines modified | Offset 33, 15 lines modified | ||
| 33 | 33 | ||
| 34 | » private·void·PopulateSkinsFromPlayers() | 34 | » private·void·PopulateSkinsFromPlayers() |
| 35 | » { | 35 | » { |
| 36 | » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) | 36 | » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) |
| 37 | » » { | 37 | » » { |
| 38 | » » » if·(!(playerControl·==·null)·&&·playerControl.CurrentOutfit·!=·null·&&·!(playerControl.gameObject·==·null)) | 38 | » » » if·(!(playerControl·==·null)·&&·playerControl.CurrentOutfit·!=·null·&&·!(playerControl.gameObject·==·null)) |
| 39 | » » » { | 39 | » » » { |
| 40 | » » » » | 40 | » » » » NetworkedPlayerInfo.PlayerOutfit·currentOutfit·=·playerControl.CurrentOutfit; |
| 41 | » » » » if·(!this.skinIds.Contains(currentOutfit.SkinId)) | 41 | » » » » if·(!this.skinIds.Contains(currentOutfit.SkinId)) |
| 42 | » » » » { | 42 | » » » » { |
| 43 | » » » » » this.skinIds.Add(currentOutfit.SkinId); | 43 | » » » » » this.skinIds.Add(currentOutfit.SkinId); |
| 44 | » » » » } | 44 | » » » » } |
| 45 | » » » } | 45 | » » » } |
| 46 | » » } | 46 | » » } |
| 47 | » } | 47 | » } |
| Offset 50, 15 lines modified | Offset 50, 15 lines modified | ||
| 50 | » { | 50 | » { |
| 51 | » » if·(GameData.Instance) | 51 | » » if·(GameData.Instance) |
| 52 | » » { | 52 | » » { |
| 53 | » » » List<byte>·list·=·new·List<byte>(); | 53 | » » » List<byte>·list·=·new·List<byte>(); |
| 54 | » » » foreach·(KeyValuePair<byte,·MushroomMixupSabotageSystem.CondensedOutfit>·keyValuePair·in·this.currentMixups) | 54 | » » » foreach·(KeyValuePair<byte,·MushroomMixupSabotageSystem.CondensedOutfit>·keyValuePair·in·this.currentMixups) |
| 55 | » » » { | 55 | » » » { |
| 56 | » » » » byte·key·=·keyValuePair.Key; | 56 | » » » » byte·key·=·keyValuePair.Key; |
| 57 | » » » » | 57 | » » » » NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(key); |
| 58 | » » » » if·(playerById·==·null·||·playerById.Disconnected·||·playerById.IsDead) | 58 | » » » » if·(playerById·==·null·||·playerById.Disconnected·||·playerById.IsDead) |
| 59 | » » » » { | 59 | » » » » { |
| 60 | » » » » » list.Add(key); | 60 | » » » » » list.Add(key); |
| 61 | » » » » } | 61 | » » » » } |
| 62 | » » » } | 62 | » » » } |
| 63 | » » » if·(list.Count·>·0) | 63 | » » » if·(list.Count·>·0) |
| 64 | » » » { | 64 | » » » { |
| Offset 154, 30 lines modified | Offset 154, 30 lines modified | ||
| 154 | » private·void·UpdatePlayerOutfits() | 154 | » private·void·UpdatePlayerOutfits() |
| 155 | » { | 155 | » { |
| 156 | » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) | 156 | » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) |
| 157 | » » { | 157 | » » { |
| 158 | » » » if·(!(playerControl·==·null)·&&·!playerControl.Data.IsDead·&&·this.currentMixups.ContainsKey(playerControl.PlayerId)) | 158 | » » » if·(!(playerControl·==·null)·&&·!playerControl.Data.IsDead·&&·this.currentMixups.ContainsKey(playerControl.PlayerId)) |
| 159 | » » » { | 159 | » » » { |
| 160 | » » » » MushroomMixupSabotageSystem.CondensedOutfit·condensedOutfit·=·this.currentMixups[playerControl.PlayerId]; | 160 | » » » » MushroomMixupSabotageSystem.CondensedOutfit·condensedOutfit·=·this.currentMixups[playerControl.PlayerId]; |
| 161 | » » » » | 161 | » » » » NetworkedPlayerInfo.PlayerOutfit·playerOutfit·=·this.ConvertToPlayerOutfit(condensedOutfit); |
| 162 | » » » » PlayerControl·player·=·playerControl; | 162 | » » » » PlayerControl·player·=·playerControl; |
| 163 | » » » » playerOutfit.NamePlateId·=·player.Data.DefaultOutfit.NamePlateId; | 163 | » » » » playerOutfit.NamePlateId·=·player.Data.DefaultOutfit.NamePlateId; |
| 164 | » » » » MushroomMixupPlayerAnimation·mushroomMixupPlayerAnimation·=·Object.Instantiate<MushroomMixupPlayerAnimation>(this.playerAnimationPrefab,·player.transform,·false); | 164 | » » » » MushroomMixupPlayerAnimation·mushroomMixupPlayerAnimation·=·Object.Instantiate<MushroomMixupPlayerAnimation>(this.playerAnimationPrefab,·player.transform,·false); |
| 165 | » » » » mushroomMixupPlayerAnimation.SetPlayer(player); | 165 | » » » » mushroomMixupPlayerAnimation.SetPlayer(player); |
| 166 | » » » » mushroomMixupPlayerAnimation.StartAnimation(ShipStatus.Instance.CosmeticsCache.CoPopulateFromOutfit(playerOutfit),·delegate | 166 | » » » » mushroomMixupPlayerAnimation.StartAnimation(ShipStatus.Instance.CosmeticsCache.CoPopulateFromOutfit(playerOutfit),·delegate |
| 167 | » » » » { | 167 | » » » » { |
| 168 | » » » » » player.MixUpOutfit(playerOutfit); | 168 | » » » » » player.MixUpOutfit(playerOutfit); |
| 169 | » » » » }); | 169 | » » » » }); |
| 170 | » » » } | 170 | » » » } |
| 171 | » » } | 171 | » » } |
| 172 | » } | 172 | » } |
| 173 | 173 | ||
| 174 | » public·void·Serialize(MessageWriter·writer,·bool·initialState) | 174 | » public·void·Serialize(MessageWriter·writer,·bool·initialState) |
| 175 | » { | 175 | » { |
| 176 | » » if·(this.cachedOutfitsByPlayerId.Count·==·0) | 176 | » » if·(this.cachedOutfitsByPlayerId.Count·==·0·&&·this.AllPlayersHaveData()) |
| 177 | » » { | 177 | » » { |
| 178 | » » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) | 178 | » » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) |
| 179 | » » » { | 179 | » » » { |
| 180 | » » » » this.cachedOutfitsByPlayerId[playerControl.PlayerId]·=·playerControl.Data.DefaultOutfit; | 180 | » » » » this.cachedOutfitsByPlayerId[playerControl.PlayerId]·=·playerControl.Data.DefaultOutfit; |
| 181 | » » » } | 181 | » » » } |
| 182 | » » } | 182 | » » } |
| 183 | » » writer.Write((byte)this.currentState); | 183 | » » writer.Write((byte)this.currentState); |
| Offset 190, 15 lines modified | Offset 190, 15 lines modified | ||
| 190 | » » } | 190 | » » } |
| 191 | » » this.currentState·=·((this.currentState·==·MushroomMixupSabotageSystem.State.JustTriggered)·?·MushroomMixupSabotageSystem.State.IdleButMixedUp·:·this.currentState); | 191 | » » this.currentState·=·((this.currentState·==·MushroomMixupSabotageSystem.State.JustTriggered)·?·MushroomMixupSabotageSystem.State.IdleButMixedUp·:·this.currentState); |
| 192 | » » this.IsDirty·=·initialState; | 192 | » » this.IsDirty·=·initialState; |
| 193 | » } | 193 | » } |
| 194 | 194 | ||
| 195 | » public·void·Deserialize(MessageReader·reader,·bool·initialState) | 195 | » public·void·Deserialize(MessageReader·reader,·bool·initialState) |
| 196 | » { | 196 | » { |
| 197 | » » if·(this.cachedOutfitsByPlayerId.Count·==·0) | 197 | » » if·(this.cachedOutfitsByPlayerId.Count·==·0·&&·this.AllPlayersHaveData()) |
| 198 | » » { | 198 | » » { |
| 199 | » » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) | 199 | » » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) |
| 200 | » » » { | 200 | » » » { |
| 201 | » » » » this.cachedOutfitsByPlayerId[playerControl.PlayerId]·=·playerControl.Data.DefaultOutfit; | 201 | » » » » this.cachedOutfitsByPlayerId[playerControl.PlayerId]·=·playerControl.Data.DefaultOutfit; |
| 202 | » » » } | 202 | » » » } |
| 203 | » » } | 203 | » » } |
| 204 | » » MushroomMixupSabotageSystem.State·state·=·this.currentState; | 204 | » » MushroomMixupSabotageSystem.State·state·=·this.currentState; |
| Offset 216, 94 lines modified | Offset 216, 109 lines modified | ||
| 216 | » » if·(state·!=·this.currentState·&&·this.currentState·==·MushroomMixupSabotageSystem.State.JustTriggered) | 216 | » » if·(state·!=·this.currentState·&&·this.currentState·==·MushroomMixupSabotageSystem.State.JustTriggered) |
| 217 | » » { | 217 | » » { |
| 218 | » » » this.MushroomMixUp(); | 218 | » » » this.MushroomMixUp(); |
| 219 | » » » this.currentState·=·MushroomMixupSabotageSystem.State.IdleButMixedUp; | 219 | » » » this.currentState·=·MushroomMixupSabotageSystem.State.IdleButMixedUp; |
| 220 | » » } | 220 | » » } |
| 221 | » } | 221 | » } |
| 222 | 222 | ||
| 223 | » private·bool·AllPlayersHaveData() | ||
| 224 | » { | ||
| 225 | » » using·(List<PlayerControl>.Enumerator·enumerator·=·PlayerControl.AllPlayerControls.GetEnumerator()) | ||
| 226 | » » { | ||
| 227 | » » » while·(enumerator.MoveNext()) | ||
| 228 | » » » { | ||
| 229 | » » » » if·(enumerator.Current.Data·==·null) | ||
| 230 | » » » » { | ||
| 231 | » » » » » return·false; | ||
| 232 | » » » » } | ||
| 233 | » » » } | ||
| 234 | » » } | ||
| 235 | » » return·true; | ||
| 236 | » } | ||
| 237 | |||
| 223 | » private·MushroomMixupSabotageSystem.CondensedOutfit·GenerateRandomOutfit(int·playerId) | 238 | » private·MushroomMixupSabotageSystem.CondensedOutfit·GenerateRandomOutfit(int·playerId) |
| 224 | » { | 239 | » { |
| 225 | » » List<byte>·list·=·new·List<byte>(this.cachedOutfitsByPlayerId.Keys); | 240 | » » List<byte>·list·=·new·List<byte>(this.cachedOutfitsByPlayerId.Keys); |
| 226 | » » list.Remove((byte)playerId); | 241 | » » list.Remove((byte)playerId); |
| 227 | » » return·new·MushroomMixupSabotageSystem.CondensedOutfit | 242 | » » return·new·MushroomMixupSabotageSystem.CondensedOutfit |
| 228 | » » { | 243 | » » { |
| 229 | » » » ColorPlayerId·=·list.Random<byte>(), | 244 | » » » ColorPlayerId·=·list.Random<byte>(), |
| 230 | » » » HatIndex·=·((Random.Range(0f,·1f)·<·this.hatEmptyChance)·?·byte.MaxValue·:·((byte)this.hatIds.RandomIdx<string>())), | 245 | » » » HatIndex·=·((Random.Range(0f,·1f)·<·this.hatEmptyChance)·?·byte.MaxValue·:·((byte)this.hatIds.RandomIdx<string>())), |
| 231 | » » » VisorIndex·=·((Random.Range(0f,·1f)·<·this.visorEmptyChance)·?·byte.MaxValue·:·((byte)this.visorIds.RandomIdx<string>())), | 246 | » » » VisorIndex·=·((Random.Range(0f,·1f)·<·this.visorEmptyChance)·?·byte.MaxValue·:·((byte)this.visorIds.RandomIdx<string>())), |
| 232 | » » » SkinIndex·=·((Random.Range(0f,·1f)·<·this.skinEmptyChance)·?·byte.MaxValue·:·((byte)this.skinIds.RandomIdx<string>())), | 247 | » » » SkinIndex·=·((Random.Range(0f,·1f)·<·this.skinEmptyChance)·?·byte.MaxValue·:·((byte)this.skinIds.RandomIdx<string>())), |
| 233 | » » » PetIndex·=·((Random.Range(0f,·1f)·<·this.petEmptyChance)·?·byte.MaxValue·:·((byte)this.petIds.RandomIdx<string>())) | 248 | » » » PetIndex·=·((Random.Range(0f,·1f)·<·this.petEmptyChance)·?·byte.MaxValue·:·((byte)this.petIds.RandomIdx<string>())) |
| 234 | » » }; | 249 | » » }; |
| 235 | » } | 250 | » } |
| 236 | 251 | ||
| 237 | » private· | 252 | » private·NetworkedPlayerInfo.PlayerOutfit·ConvertToPlayerOutfit(MushroomMixupSabotageSystem.CondensedOutfit·condensedOutfit) |
| 238 | » { | 253 | » { |
| 239 | » » return·new· | 254 | » » return·new·NetworkedPlayerInfo.PlayerOutfit |
| 240 | » » { | 255 | » » { |
| 241 | » » » ColorId·=·(this.cachedOutfitsByPlayerId.ContainsKey(condensedOutfit.ColorPlayerId)·?·this.cachedOutfitsByPlayerId[condensedOutfit.ColorPlayerId].ColorId·:·this.deadAndDcPlayerOutfitsByPlayerId[condensedOutfit.ColorPlayerId].ColorId), | 256 | » » » ColorId·=·(this.cachedOutfitsByPlayerId.ContainsKey(condensedOutfit.ColorPlayerId)·?·this.cachedOutfitsByPlayerId[condensedOutfit.ColorPlayerId].ColorId·:·this.deadAndDcPlayerOutfitsByPlayerId[condensedOutfit.ColorPlayerId].ColorId), |
| 242 | » » » HatId·=·(((int)condensedOutfit.HatIndex·>=·this.hatIds.Length)·?·"hat_NoHat"·:·this.hatIds[(int)condensedOutfit.HatIndex]), | 257 | » » » HatId·=·(((int)condensedOutfit.HatIndex·>=·this.hatIds.Length)·?·"hat_NoHat"·:·this.hatIds[(int)condensedOutfit.HatIndex]), |
| 243 | » » » SkinId·=·(((int)condensedOutfit.SkinIndex·>=·this.skinIds.Count)·?·"skin_None"·:·this.skinIds[(int)condensedOutfit.SkinIndex]), | 258 | » » » SkinId·=·(((int)condensedOutfit.SkinIndex·>=·this.skinIds.Count)·?·"skin_None"·:·this.skinIds[(int)condensedOutfit.SkinIndex]), |
| 244 | » » » VisorId·=·(((int)condensedOutfit.VisorIndex·>=·this.visorIds.Length)·?·"visor_EmptyVisor"·:·this.visorIds[(int)condensedOutfit.VisorIndex]), | 259 | » » » VisorId·=·(((int)condensedOutfit.VisorIndex·>=·this.visorIds.Length)·?·"visor_EmptyVisor"·:·this.visorIds[(int)condensedOutfit.VisorIndex]), |
| 245 | » » » PetId·=·(((int)condensedOutfit.PetIndex·>=·this.petIds.Length)·?·"pet_EmptyPet"·:·this.petIds[(int)condensedOutfit.PetIndex]) | 260 | » » » PetId·=·(((int)condensedOutfit.PetIndex·>=·this.petIds.Length)·?·"pet_EmptyPet"·:·this.petIds[(int)condensedOutfit.PetIndex]) |
| 246 | » » }; | 261 | » » }; |
| 247 | » } | 262 | » } |
| 248 | 263 | ||
| Max diff block lines reached; 1983/7938 bytes (24.98%) of diff not shown. | |||
| Offset 24, 14 lines modified | Offset 24, 18 lines modified | ||
| 24 | » » if·(this.open·==·open) | 24 | » » if·(this.open·==·open) |
| 25 | » » { | 25 | » » { |
| 26 | » » » return; | 26 | » » » return; |
| 27 | » » } | 27 | » » } |
| 28 | » » this.open·=·open; | 28 | » » this.open·=·open; |
| 29 | » » this.wallCollider.isTrigger·=·open; | 29 | » » this.wallCollider.isTrigger·=·open; |
| 30 | » » this.shadowColl.enabled·=·!open; | 30 | » » this.shadowColl.enabled·=·!open; |
| 31 | » » if·(this.bottomColl·!=·null) | ||
| 32 | » » { | ||
| 33 | » » » this.bottomColl.enabled·=·!open; | ||
| 34 | » » } | ||
| 31 | » » foreach·(MushroomWallMushroom·mushroomWallMushroom·in·this.mushrooms) | 35 | » » foreach·(MushroomWallMushroom·mushroomWallMushroom·in·this.mushrooms) |
| 32 | » » { | 36 | » » { |
| 33 | » » » if·(open) | 37 | » » » if·(open) |
| 34 | » » » { | 38 | » » » { |
| 35 | » » » » mushroomWallMushroom.Hide(); | 39 | » » » » mushroomWallMushroom.Hide(); |
| 36 | » » » } | 40 | » » » } |
| 37 | » » » else | 41 | » » » else |
| Offset 92, 14 lines modified | Offset 96, 17 lines modified | ||
| 92 | » [SerializeField] | 96 | » [SerializeField] |
| 93 | » private·BoxCollider2D·wallCollider; | 97 | » private·BoxCollider2D·wallCollider; |
| 94 | 98 | ||
| 95 | » [SerializeField] | 99 | » [SerializeField] |
| 96 | » private·Collider2D·shadowColl; | 100 | » private·Collider2D·shadowColl; |
| 97 | 101 | ||
| 98 | » [SerializeField] | 102 | » [SerializeField] |
| 103 | » private·Collider2D·bottomColl; | ||
| 104 | |||
| 105 | » [SerializeField] | ||
| 99 | » private·MushroomWallMushroom[]·mushrooms; | 106 | » private·MushroomWallMushroom[]·mushrooms; |
| 100 | 107 | ||
| 101 | » [SerializeField] | 108 | » [SerializeField] |
| 102 | » private·AudioClip·openSound; | 109 | » private·AudioClip·openSound; |
| 103 | 110 | ||
| 104 | » [SerializeField] | 111 | » [SerializeField] |
| 105 | » private·AudioClip·closeSound; | 112 | » private·AudioClip·closeSound; |
| Offset 631, 28 lines modified | Offset 631, 28 lines modified | ||
| 631 | 631 | ||
| 632 | » public·float·TaskTimer; | 632 | » public·float·TaskTimer; |
| 633 | 633 | ||
| 634 | » public·byte[]·Data; | 634 | » public·byte[]·Data; |
| 635 | 635 | ||
| 636 | » public·ArrowBehaviour·Arrow; | 636 | » public·ArrowBehaviour·Arrow; |
| 637 | 637 | ||
| 638 | » [Tooltip("To·have·multiple·texts·on·multistage·tasks")] | ||
| 639 | » [SerializeField] | 638 | » [SerializeField] |
| 639 | » [Tooltip("To·have·multiple·texts·on·multistage·tasks")] | ||
| 640 | » private·bool·useMultipleText; | 640 | » private·bool·useMultipleText; |
| 641 | 641 | ||
| 642 | » [SerializeField] | ||
| 643 | » [Tooltip("For·tasks·that·need·a·number·of·steps·completed·before·stage·2")] | 642 | » [Tooltip("For·tasks·that·need·a·number·of·steps·completed·before·stage·2")] |
| 643 | » [SerializeField] | ||
| 644 | » private·int·maxNumStepsStage1; | 644 | » private·int·maxNumStepsStage1; |
| 645 | 645 | ||
| 646 | » [Tooltip("Used·only·if·useMultipleText·is·selected")] | ||
| 647 | » [SerializeField] | 646 | » [SerializeField] |
| 647 | » [Tooltip("Used·only·if·useMultipleText·is·selected")] | ||
| 648 | » private·StringNames·textStage1; | 648 | » private·StringNames·textStage1; |
| 649 | 649 | ||
| 650 | » [Tooltip("Used·only·if·useMultipleText·is·selected")] | ||
| 651 | » [SerializeField] | 650 | » [SerializeField] |
| 651 | » [Tooltip("Used·only·if·useMultipleText·is·selected")] | ||
| 652 | » private·StringNames·textStage2; | 652 | » private·StringNames·textStage2; |
| 653 | 653 | ||
| 654 | » protected·bool·arrowSuspended; | 654 | » protected·bool·arrowSuspended; |
| 655 | 655 | ||
| 656 | » public·enum·TaskLength | 656 | » public·enum·TaskLength |
| 657 | » { | 657 | » { |
| 658 | » » None, | 658 | » » None, |
| Offset 1, 56 lines modified | Offset 1, 162 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Text; | ||
| 3 | using· | 2 | using·System.Collections.Generic; |
| 3 | using·AmongUs.GameOptions; | ||
| 4 | using·UnityEngine; | 4 | using·UnityEngine; |
| 5 | 5 | ||
| 6 | public·class·NotificationPopper·:·MonoBehaviour | 6 | public·class·NotificationPopper·:·MonoBehaviour |
| 7 | { | 7 | { |
| 8 | » p | 8 | » private·void·Awake() |
| 9 | » { | 9 | » { |
| 10 | » » i | 10 | » » this.activeMessages·=·new·List<LobbyNotificationMessage>(); |
| 11 | » } | ||
| 12 | |||
| 13 | » private·void·Update() | ||
| 14 | » { | ||
| 15 | » } | ||
| 16 | |||
| 17 | » public·void·AddDisconnectMessage(string·item) | ||
| 18 | » { | ||
| 19 | » » LobbyNotificationMessage·newMessage·=·Object.Instantiate<LobbyNotificationMessage>(this.notificationMessageOrigin,·Vector3.zero,·Quaternion.identity,·base.transform); | ||
| 20 | » » newMessage.transform.localPosition·=·new·Vector3(0f,·0f,·-2f); | ||
| 21 | » » newMessage.SetUp(item,·this.playerDisconnectSprite,·this.disconnectColor,·delegate | ||
| 22 | » » { | ||
| 23 | » » » this.OnMessageDestroy(newMessage); | ||
| 24 | » » }); | ||
| 25 | » » SoundManager.Instance.PlaySound(this.playerDisconnectSound,·false,·1f,·null); | ||
| 26 | » » this.ShiftMessages(); | ||
| 27 | » » this.AddMessageToQueue(newMessage); | ||
| 28 | » } | ||
| 29 | |||
| 30 | » public·void·AddSettingsChangeMessage(StringNames·key,·string·value,·bool·playSound·=·true,·RoleTypes·associatedRole·=·RoleTypes.Crewmate) | ||
| 31 | » { | ||
| 32 | » » string·text·=·string.Empty; | ||
| 33 | » » if·(associatedRole·!=·RoleTypes.Crewmate) | ||
| 11 | » » { | 34 | » » { |
| 12 | » » » i | 35 | » » » string·text2·=·(RoleManager.IsImpostorRole(associatedRole)·?·Palette.ImpostorRed.ToTextColor()·:·Palette.CrewmateSettingChangeText.ToTextColor()); |
| 36 | » » » text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyChangeSettingNotification,·new·object[] | ||
| 13 | » » » { | 37 | » » » { |
| 14 | » » » » t | 38 | » » » » string.Concat(new·string[] |
| 39 | » » » » { | ||
| 40 | » » » » » "<sprite·name=\"", | ||
| 41 | » » » » » associatedRole.ToString(), | ||
| 42 | » » » » » "Role\">·<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">", | ||
| 43 | » » » » » text2, | ||
| 44 | » » » » » DestroyableSingleton<TranslationController>.Instance.GetString(key,·Array.Empty<object>()), | ||
| 45 | » » » » » "</color></font>" | ||
| 46 | » » » » }), | ||
| 47 | » » » » "<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">"·+·value·+·"</font>" | ||
| 48 | » » » }); | ||
| 15 | » » | 49 | » » } |
| 16 | » » » float·num·=·this.mainCamera.orthographicSize·*·this.mainCamera.aspect; | ||
| 17 | » » » float·y·=·DestroyableSingleton<HudManager>.Instance.GameSettings.bounds.size.y; | ||
| 18 | » » » Transform·transform·=·DestroyableSingleton<HudManager>.Instance.GameSettings.transform; | ||
| 19 | » » » base.transform.localPosition·=·new·Vector3(-num·+·0.1f,·transform.localPosition.y·-·y,·this.zPos); | ||
| 20 | » » » this.alphaTimer·-=·Time.deltaTime; | ||
| 21 | » » » this.textColor.a·=·Mathf.Clamp(this.alphaTimer·/·this.FadeDuration,·0f,·1f); | ||
| 22 | » » » this.TextArea.color·=·this.textColor; | ||
| 23 | » » | 50 | » » else |
| 51 | » » { | ||
| 52 | » » » text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyChangeSettingNotification,·new·object[] | ||
| 53 | » » » { | ||
| 54 | » » » » "<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">"·+·DestroyableSingleton<TranslationController>.Instance.GetString(key,·Array.Empty<object>())·+·"</font>", | ||
| 55 | » » » » "<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">"·+·value·+·"</font>" | ||
| 56 | » » » }); | ||
| 57 | » » } | ||
| 58 | » » this.SettingsChangeMessageLogic(key,·text,·playSound); | ||
| 59 | » } | ||
| 60 | |||
| 61 | » public·void·AddRoleSettingsChangeMessage(StringNames·key,·int·roleCount,·int·roleChance,·RoleTeamTypes·teamType,·bool·playSound·=·true) | ||
| 62 | » { | ||
| 63 | » » string·text·=·string.Empty; | ||
| 64 | » » string·text2·=·((teamType·==·RoleTeamTypes.Crewmate)·?·Palette.CrewmateSettingChangeText.ToTextColor()·:·Palette.ImpostorRed.ToTextColor()); | ||
| 65 | » » text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyChangeSettingNotificationRole,·new·object[] | ||
| 66 | » » { | ||
| 67 | » » » string.Concat(new·string[] | ||
| 68 | » » » { | ||
| 69 | » » » » "<sprite·name=\"", | ||
| 70 | » » » » key.ToString(), | ||
| 71 | » » » » "\">·<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">", | ||
| 72 | » » » » text2, | ||
| 73 | » » » » DestroyableSingleton<TranslationController>.Instance.GetString(key,·Array.Empty<object>()), | ||
| 74 | » » » » "</color></font>" | ||
| 75 | » » » }), | ||
| 76 | » » » "<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">"·+·roleCount.ToString()·+·"</font>", | ||
| 77 | » » » "<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">"·+·roleChance.ToString()·+·"%" | ||
| 78 | » » }); | ||
| 79 | » » this.SettingsChangeMessageLogic(key,·text,·playSound); | ||
| 80 | » } | ||
| 81 | |||
| 82 | » private·void·SettingsChangeMessageLogic(StringNames·key,·string·item,·bool·playSound) | ||
| 83 | » { | ||
| 84 | » » if·(this.lastMessageKey·==·(int)key·&&·this.activeMessages.Count·>·0) | ||
| 85 | » » { | ||
| 86 | » » » this.activeMessages[this.activeMessages.Count·-·1].UpdateMessage(item); | ||
| 87 | » » } | ||
| 88 | » » else | ||
| 89 | » » { | ||
| 90 | » » » this.lastMessageKey·=·(int)key; | ||
| 91 | » » » LobbyNotificationMessage·newMessage·=·Object.Instantiate<LobbyNotificationMessage>(this.notificationMessageOrigin,·Vector3.zero,·Quaternion.identity,·base.transform); | ||
| 92 | » » » newMessage.transform.localPosition·=·new·Vector3(0f,·0f,·-2f); | ||
| 93 | » » » newMessage.SetUp(item,·this.settingsChangeSprite,·this.settingsChangeColor,·delegate | ||
| 24 | » » » { | 94 | » » » { |
| 25 | » » » » this.builder.Clear(); | ||
| 26 | » » » » this. | 95 | » » » » this.OnMessageDestroy(newMessage); |
| 96 | » » » }); | ||
| 97 | » » » this.ShiftMessages(); | ||
| 98 | » » » this.AddMessageToQueue(newMessage); | ||
| 27 | » » | 99 | » » } |
| 100 | » » if·(playSound) | ||
| 101 | » » { | ||
| 102 | » » » SoundManager.Instance.PlaySoundImmediate(this.settingsChangeSound,·false,·1f,·1f,·null); | ||
| 103 | » » } | ||
| 104 | » } | ||
| 105 | |||
| 106 | » private·void·AddMessageToQueue(LobbyNotificationMessage·newMessage) | ||
| 107 | » { | ||
| 108 | » » while·(this.activeMessages.Count·>=·this.maxMessages) | ||
| 109 | » » { | ||
| 110 | » » » Object.Destroy(this.activeMessages[0].gameObject); | ||
| 111 | » » » this.activeMessages.RemoveAt(0); | ||
| 112 | » » } | ||
| 113 | » » this.activeMessages.Add(newMessage); | ||
| 114 | » } | ||
| 115 | |||
| 116 | » private·void·ShiftMessages() | ||
| 117 | » { | ||
| 118 | » » foreach·(LobbyNotificationMessage·lobbyNotificationMessage·in·this.activeMessages) | ||
| Max diff block lines reached; 1429/7059 bytes (20.24%) of diff not shown. | |||
| Offset 1, 160 lines modified | Offset 1, 146 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·AmongUs.GameOptions; | 2 | using·AmongUs.GameOptions; |
| 3 | using·TMPro; | 3 | using·TMPro; |
| 4 | using·UnityEngine; | 4 | using·UnityEngine; |
| 5 | 5 | ||
| 6 | public·class·NumberOption·:·OptionBehaviour | 6 | public·class·NumberOption·:·OptionBehaviour |
| 7 | { | 7 | { |
| 8 | » public·void· | 8 | » public·override·void·SetUpFromData(BaseGameSetting·data,·int·maskLayer) |
| 9 | » { | 9 | » { |
| 10 | » » base.SetUpFromData(data,·maskLayer); | ||
| 11 | » » if·(data.Type·==·OptionTypes.Float) | ||
| 10 | » » this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>()); | ||
| 11 | » » this.FixedUpdate(); | ||
| 12 | » » IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions; | ||
| 13 | » » StringNames·title·=·this.Title; | ||
| 14 | » » if·(title·<=·StringNames.ImpostorFlashlightSize) | ||
| 15 | » » { | 12 | » » { |
| 16 | » » » | 13 | » » » FloatGameSetting·floatGameSetting·=·data·as·FloatGameSetting; |
| 14 | » » » if·(floatGameSetting·==·null) | ||
| 17 | » » » { | 15 | » » » { |
| 18 | » » » case·StringNames.GameNumImpostors: | ||
| 19 | » » » » this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.NumImpostors); | ||
| 20 | » » » » return; | ||
| 21 | » » » case·StringNames.GameNumMeetings: | ||
| 22 | » » » » this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.NumEmergencyMeetings); | ||
| 23 | » » » » return; | ||
| 24 | » » » case·StringNames.GameDiscussTime: | ||
| 25 | » » » » this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.DiscussionTime); | ||
| 26 | » » » » return; | ||
| 27 | » » » case·StringNames.GameVotingTime: | ||
| 28 | » » » » this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.VotingTime); | ||
| 29 | » » » » return; | ||
| 30 | » » » case·StringNames.GamePlayerSpeed: | ||
| 31 | » » » » this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.PlayerSpeedMod); | ||
| 32 | » » » » return; | ||
| 33 | » » » case·StringNames.GameCrewLight: | ||
| 34 | » » » » this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.CrewLightMod); | ||
| 35 | » » » » return; | ||
| 36 | » » » case·StringNames.GameImpostorLight: | ||
| 37 | » » » » this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.ImpostorLightMod); | ||
| 38 | » » » » return; | 16 | » » » » return; |
| 39 | » » » case·StringNames.GameKillCooldown: | ||
| 40 | » » » » this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.KillCooldown); | ||
| 41 | » » » » return; | ||
| 42 | » » » case·StringNames.GameKillDistance: | ||
| 43 | » » » » break; | ||
| 44 | » » » case·StringNames.GameCommonTasks: | ||
| 45 | » » » » this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.NumCommonTasks); | ||
| 46 | » » » » return; | ||
| 47 | » » » case·StringNames.GameLongTasks: | ||
| 48 | » » » » this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.NumLongTasks); | ||
| 49 | » » » » return; | ||
| 50 | » » » case·StringNames.GameShortTasks: | ||
| 51 | » » » » this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.NumShortTasks); | ||
| 52 | » » » » return; | ||
| 53 | » » » default: | ||
| 54 | » » » » if·(title·==·StringNames.GameEmergencyCooldown) | ||
| 55 | » » » » { | ||
| 56 | » » » » » this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.EmergencyCooldown); | ||
| 57 | » » » » » return; | ||
| 58 | » » » » } | ||
| 59 | » » » » switch·(title) | ||
| 60 | » » » » { | ||
| 61 | » » » » case·StringNames.MaxVentUses: | ||
| 62 | » » » » » this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.CrewmateVentUses); | ||
| 63 | » » » » » return; | ||
| 64 | » » » » case·StringNames.MaxTimeInVent: | ||
| 65 | » » » » » this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.CrewmateTimeInVent); | ||
| 66 | » » » » » return; | ||
| 67 | » » » » case·StringNames.MinCrewmatesForVitals: | ||
| 68 | » » » » » this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.CrewmatesRemainingForVitals); | ||
| 69 | » » » » » return; | ||
| 70 | » » » » case·StringNames.EscapeTime: | ||
| 71 | » » » » » this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.EscapeTime); | ||
| 72 | » » » » » return; | ||
| 73 | » » » » case·StringNames.AllTasksComplete: | ||
| 74 | » » » » case·StringNames.EscapePrompt: | ||
| 75 | » » » » » break; | ||
| 76 | » » » » case·StringNames.CrewmateFlashlightSize: | ||
| 77 | » » » » » this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.CrewmateFlashlightSize); | ||
| 78 | » » » » » return; | ||
| 79 | » » » » case·StringNames.ImpostorFlashlightSize: | ||
| 80 | » » » » » this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.ImpostorFlashlightSize); | ||
| 81 | » » » » » return; | ||
| 82 | » » » » default: | ||
| 83 | » » » » » return; | ||
| 84 | » » » » } | ||
| 85 | » » » » break; | ||
| 86 | » » » } | 17 | » » » } |
| 18 | » » » this.Title·=·floatGameSetting.Title; | ||
| 19 | » » » this.Value·=·floatGameSetting.Value; | ||
| 20 | » » » this.Increment·=·floatGameSetting.Increment; | ||
| 21 | » » » this.ValidRange·=·floatGameSetting.ValidRange; | ||
| 22 | » » » this.FormatString·=·floatGameSetting.FormatString; | ||
| 23 | » » » this.ZeroIsInfinity·=·floatGameSetting.ZeroIsInfinity; | ||
| 24 | » » » this.SuffixType·=·floatGameSetting.SuffixType; | ||
| 25 | » » » this.floatOptionName·=·floatGameSetting.OptionName; | ||
| 26 | » » » return; | ||
| 87 | » » } | 27 | » » } |
| 88 | » » else | 28 | » » else |
| 89 | » » { | 29 | » » { |
| 30 | » » » if·(data.Type·!=·OptionTypes.Int) | ||
| 90 | » » » if·(title·==·StringNames.FinalEscapeTime) | ||
| 91 | » » » { | ||
| 92 | » » » » this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.FinalEscapeTime); | ||
| 93 | » » » » return; | ||
| 94 | » » » } | ||
| 95 | » » » if·(title·==·StringNames.SeekerFinalSpeed) | ||
| 96 | » » » { | 31 | » » » { |
| 97 | » » » » | 32 | » » » » Debug.LogError("Could·not·set·up·NumberOption·for·"·+·data.Title.ToString()); |
| 98 | » » » » return; | 33 | » » » » return; |
| 99 | » » » } | 34 | » » » } |
| 100 | » » » | 35 | » » » IntGameSetting·intGameSetting·=·data·as·IntGameSetting; |
| 36 | » » » if·(intGameSetting·==·null) | ||
| 101 | » » » { | 37 | » » » { |
| 102 | » » » » return; | 38 | » » » » return; |
| 103 | » » » } | 39 | » » » } |
| 104 | » » » this. | 40 | » » » this.Title·=·intGameSetting.Title; |
| 41 | » » » this.Value·=·(float)intGameSetting.Value; | ||
| 42 | » » » this.Increment·=·(float)intGameSetting.Increment; | ||
| 43 | » » » this.ValidRange·=·new·FloatRange((float)intGameSetting.ValidRange.min,·(float)intGameSetting.ValidRange.max); | ||
| 44 | » » » this.FormatString·=·intGameSetting.FormatString; | ||
| 45 | » » » this.ZeroIsInfinity·=·intGameSetting.ZeroIsInfinity; | ||
| 46 | » » » this.SuffixType·=·intGameSetting.SuffixType; | ||
| 47 | » » » this.intOptionName·=·intGameSetting.OptionName; | ||
| 48 | » » » return; | ||
| 105 | » » } | 49 | » » } |
| Max diff block lines reached; 3345/8563 bytes (39.06%) of diff not shown. | |||
| Offset 29, 15 lines modified | Offset 29, 15 lines modified | ||
| 29 | 29 | ||
| 30 | » public·void·Awake() | 30 | » public·void·Awake() |
| 31 | » { | 31 | » { |
| 32 | » » this.myDoor·=·base.GetComponent<OpenableDoor>(); | 32 | » » this.myDoor·=·base.GetComponent<OpenableDoor>(); |
| 33 | » » this.image·=·base.GetComponent<SpriteRenderer>(); | 33 | » » this.image·=·base.GetComponent<SpriteRenderer>(); |
| 34 | » } | 34 | » } |
| 35 | 35 | ||
| 36 | » public·float·CanUse( | 36 | » public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse) |
| 37 | » { | 37 | » { |
| 38 | » » float·num·=·Vector2.Distance(pc.Object.GetTruePosition(),·base.transform.position); | 38 | » » float·num·=·Vector2.Distance(pc.Object.GetTruePosition(),·base.transform.position); |
| 39 | » » couldUse·=·!pc.IsDead·&&·!this.myDoor.IsOpen; | 39 | » » couldUse·=·!pc.IsDead·&&·!this.myDoor.IsOpen; |
| 40 | » » canUse·=·couldUse·&&·num·<=·this.UsableDistance; | 40 | » » canUse·=·couldUse·&&·num·<=·this.UsableDistance; |
| 41 | » » return·num; | 41 | » » return·num; |
| 42 | » } | 42 | » } |
| 43 | 43 | ||
| Offset 1, 12 lines modified | Offset 1, 22 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·AmongUs.GameOptions; | ||
| 3 | using·TMPro; | ||
| 2 | using·UnityEngine; | 4 | using·UnityEngine; |
| 3 | 5 | ||
| 4 | public·abstract·class·OptionBehaviour·:·MonoBehaviour | 6 | public·abstract·class·OptionBehaviour·:·MonoBehaviour |
| 5 | { | 7 | { |
| 8 | » public·BaseGameSetting·Data | ||
| 9 | » { | ||
| 10 | » » get | ||
| 11 | » » { | ||
| 12 | » » » return·this.data; | ||
| 13 | » » } | ||
| 14 | » } | ||
| 15 | |||
| 6 | » public·virtual·float·GetFloat() | 16 | » public·virtual·float·GetFloat() |
| 7 | » { | 17 | » { |
| 8 | » » throw·new·NotImplementedException(); | 18 | » » throw·new·NotImplementedException(); |
| 9 | » } | 19 | » } |
| 10 | 20 | ||
| 11 | » public·virtual·int·GetInt() | 21 | » public·virtual·int·GetInt() |
| 12 | » { | 22 | » { |
| Offset 16, 18 lines modified | Offset 26, 65 lines modified | ||
| 16 | » public·virtual·bool·GetBool() | 26 | » public·virtual·bool·GetBool() |
| 17 | » { | 27 | » { |
| 18 | » » throw·new·NotImplementedException(); | 28 | » » throw·new·NotImplementedException(); |
| 19 | » } | 29 | » } |
| 20 | 30 | ||
| 21 | » public·void·SetAsPlayer() | 31 | » public·void·SetAsPlayer() |
| 22 | » { | 32 | » { |
| 33 | » » if·(this.buttons·==·null·||·this.buttons.Length·==·0) | ||
| 34 | » » { | ||
| 23 | » » | 35 | » » » this.buttons·=·base.GetComponentsInChildren<PassiveButton>(); |
| 36 | » » } | ||
| 37 | » » for·(int·i·=·0;·i·<·this.buttons.Length;·i++) | ||
| 38 | » » { | ||
| 39 | » » » this.buttons[i].gameObject.SetActive(false); | ||
| 40 | » » } | ||
| 41 | » } | ||
| 42 | |||
| 43 | » public·void·SetClickMask(Collider2D·clickMask) | ||
| 44 | » { | ||
| 45 | » » if·(this.buttons·==·null·||·this.buttons.Length·==·0) | ||
| 46 | » » { | ||
| 47 | » » » this.buttons·=·base.GetComponentsInChildren<PassiveButton>(); | ||
| 48 | » » } | ||
| 49 | » » for·(int·i·=·0;·i·<·this.buttons.Length;·i++) | ||
| 50 | » » { | ||
| 51 | » » » this.buttons[i].ClickMask·=·clickMask; | ||
| 52 | » » } | ||
| 53 | » } | ||
| 54 | |||
| 55 | » public·virtual·void·SetUpFromData(BaseGameSetting·data,·int·maskLayer) | ||
| 56 | » { | ||
| 57 | » » this.data·=·data; | ||
| 58 | » » SpriteRenderer[]·componentsInChildren·=·base.GetComponentsInChildren<SpriteRenderer>(true); | ||
| 24 | » » for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++) | 59 | » » for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++) |
| 25 | » » { | 60 | » » { |
| 26 | » » » componentsInChildren[i]. | 61 | » » » componentsInChildren[i].material.SetInt(PlayerMaterial.MaskLayer,·maskLayer); |
| 62 | » » } | ||
| 63 | » » foreach·(TextMeshPro·textMeshPro·in·base.GetComponentsInChildren<TextMeshPro>(true)) | ||
| 64 | » » { | ||
| 65 | » » » textMeshPro.fontMaterial.SetFloat("_StencilComp",·3f); | ||
| 66 | » » » textMeshPro.fontMaterial.SetFloat("_Stencil",·(float)maskLayer); | ||
| 27 | » » } | 67 | » » } |
| 28 | » } | 68 | » } |
| 29 | 69 | ||
| 70 | » public·virtual·void·Initialize() | ||
| 71 | » { | ||
| 72 | » } | ||
| 73 | |||
| 74 | » public·string·GetValueString(float·value) | ||
| 75 | » { | ||
| 76 | » » return·this.data.GetValueString(value); | ||
| 77 | » } | ||
| 78 | |||
| 79 | » public·SpriteRenderer·LabelBackground; | ||
| 80 | |||
| 30 | » public·StringNames·Title; | 81 | » public·StringNames·Title; |
| 31 | 82 | ||
| 32 | » public·Action<OptionBehaviour>·OnValueChanged; | 83 | » public·Action<OptionBehaviour>·OnValueChanged; |
| 84 | |||
| 85 | » public·RoleTypes·AssociatedRole; | ||
| 86 | |||
| 87 | » protected·BaseGameSetting·data; | ||
| 88 | |||
| 89 | » private·PassiveButton[]·buttons; | ||
| 33 | } | 90 | } |
| Offset 23, 15 lines modified | Offset 23, 15 lines modified | ||
| 23 | » { | 23 | » { |
| 24 | » » get | 24 | » » get |
| 25 | » » { | 25 | » » { |
| 26 | » » » return·0f; | 26 | » » » return·0f; |
| 27 | » » } | 27 | » » } |
| 28 | » } | 28 | » } |
| 29 | 29 | ||
| 30 | » public·float·CanUse( | 30 | » public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse) |
| 31 | » { | 31 | » { |
| 32 | » » float·num·=·float.MaxValue; | 32 | » » float·num·=·float.MaxValue; |
| 33 | » » PlayerControl·@object·=·pc.Object; | 33 | » » PlayerControl·@object·=·pc.Object; |
| 34 | » » couldUse·=·@object.CanMove; | 34 | » » couldUse·=·@object.CanMove; |
| 35 | » » if·(this.HostOnly) | 35 | » » if·(this.HostOnly) |
| 36 | » » { | 36 | » » { |
| 37 | » » » couldUse·&=·AmongUsClient.Instance.AmHost; | 37 | » » » couldUse·&=·AmongUsClient.Instance.AmHost; |
| Offset 62, 14 lines modified | Offset 62, 19 lines modified | ||
| 62 | » » » » this.ControllerSelectable.Add(uiElement); | 62 | » » » » this.ControllerSelectable.Add(uiElement); |
| 63 | » » » } | 63 | » » » } |
| 64 | » » } | 64 | » » } |
| 65 | » } | 65 | » } |
| 66 | 66 | ||
| 67 | » private·void·OnDisable() | 67 | » private·void·OnDisable() |
| 68 | » { | 68 | » { |
| 69 | » » PassiveButton·menuButton·=·this.MenuButton; | ||
| 70 | » » if·(menuButton·!=·null) | ||
| 71 | » » { | ||
| 72 | » » » menuButton.SelectButton(false); | ||
| 73 | » » } | ||
| 69 | » » DataManager.Settings.Save(); | 74 | » » DataManager.Settings.Save(); |
| 70 | » } | 75 | » } |
| 71 | 76 | ||
| 72 | » public·void·OnDestroy() | 77 | » public·void·OnDestroy() |
| 73 | » { | 78 | » { |
| 74 | » » if·(DestroyableSingleton<TranslationController>.InstanceExists) | 79 | » » if·(DestroyableSingleton<TranslationController>.InstanceExists) |
| 75 | » » { | 80 | » » { |
| Offset 102, 14 lines modified | Offset 107, 19 lines modified | ||
| 102 | » » if·(Minigame.Instance·!=·null) | 107 | » » if·(Minigame.Instance·!=·null) |
| 103 | » » { | 108 | » » { |
| 104 | » » » Minigame.Instance.Close(); | 109 | » » » Minigame.Instance.Close(); |
| 105 | » » } | 110 | » » } |
| 106 | » » this.OpenTabGroup(0); | 111 | » » this.OpenTabGroup(0); |
| 107 | » » this.UpdateButtons(); | 112 | » » this.UpdateButtons(); |
| 108 | » » base.gameObject.SetActive(true); | 113 | » » base.gameObject.SetActive(true); |
| 114 | » » PassiveButton·menuButton·=·this.MenuButton; | ||
| 115 | » » if·(menuButton·!=·null) | ||
| 116 | » » { | ||
| 117 | » » » menuButton.SelectButton(true); | ||
| 118 | » » } | ||
| 109 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | 119 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) |
| 110 | » » { | 120 | » » { |
| 111 | » » » ConsoleJoystick.SetMode_MenuAdditive(); | 121 | » » » ConsoleJoystick.SetMode_MenuAdditive(); |
| 112 | » » } | 122 | » » } |
| 113 | » » if·(!this.grabbedControllerButtons) | 123 | » » if·(!this.grabbedControllerButtons) |
| 114 | » » { | 124 | » » { |
| 115 | » » » this.grabbedControllerButtons·=·true; | 125 | » » » this.grabbedControllerButtons·=·true; |
| Offset 272, 14 lines modified | Offset 282, 16 lines modified | ||
| 272 | 282 | ||
| 273 | » public·BugReportPopup·bugReportPopup; | 283 | » public·BugReportPopup·bugReportPopup; |
| 274 | 284 | ||
| 275 | » public·bool·Toggle·=·true; | 285 | » public·bool·Toggle·=·true; |
| 276 | 286 | ||
| 277 | » public·TabGroup[]·Tabs; | 287 | » public·TabGroup[]·Tabs; |
| 278 | 288 | ||
| 289 | » public·PassiveButton·MenuButton; | ||
| 290 | |||
| 279 | » private·bool·grabbedControllerButtons; | 291 | » private·bool·grabbedControllerButtons; |
| 280 | 292 | ||
| 281 | » [Header("Console·Controller·Navigation")] | 293 | » [Header("Console·Controller·Navigation")] |
| 282 | » public·UiElement·BackButton; | 294 | » public·UiElement·BackButton; |
| 283 | 295 | ||
| 284 | » public·UiElement·DefaultButtonSelected; | 296 | » public·UiElement·DefaultButtonSelected; |
| 285 | 297 | ||
| Offset 1, 53 lines modified | Offset 1, 65 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections; | 2 | using·System.Collections; |
| 3 | using·System.Collections.Generic; | 3 | using·System.Collections.Generic; |
| 4 | using·PowerTools; | 4 | using·PowerTools; |
| 5 | using·UnityEngine; | 5 | using·UnityEngine; |
| 6 | using·UnityEngine.AddressableAssets; | ||
| 6 | 7 | ||
| 7 | public·class·OverlayKillAnimation·:·OverlayAnimation | 8 | public·class·OverlayKillAnimation·:·OverlayAnimation |
| 8 | { | 9 | { |
| 9 | » public· | 10 | » public·bool·LeftFacingVictim |
| 10 | » { | 11 | » { |
| 12 | » » get | ||
| 13 | » » { | ||
| 14 | » » » return·this.leftFacingVictim; | ||
| 15 | » » } | ||
| 16 | » } | ||
| 17 | |||
| 18 | » public·virtual·void·Initialize(KillOverlayInitData·initData) | ||
| 19 | » { | ||
| 20 | » » this.initData·=·initData; | ||
| 11 | » » if·(this.killerParts) | 21 | » » if·(this.killerParts) |
| 12 | » » { | 22 | » » { |
| 13 | » » » PlayerControl·playerControl·=·PlayerControl.AllPlayerControls.Find((PlayerControl·p)·=>·p.PlayerId·==·kInfo.PlayerId); | ||
| 14 | » » » GameData.PlayerOutfit·killerOutfit·=·playerControl.CurrentOutfit; | ||
| 15 | » » » this.killerParts.SetBodyType( | 23 | » » » this.killerParts.SetBodyType(initData.killerBodyType); |
| 16 | » » » this.killerParts.UpdateFromPlayer | 24 | » » » this.killerParts.UpdateFromPlayerOutfit(initData.killerOutfit,·PlayerMaterial.MaskType.None,·false,·false,·delegate |
| 17 | » » » { | 25 | » » » { |
| 18 | » » » » this.LoadKillerSkin(killerOutfit); | 26 | » » » » this.LoadKillerSkin(initData.killerOutfit); |
| 19 | » » » },·false); | 27 | » » » },·false); |
| 20 | » » » this.killerParts.ToggleName(false); | 28 | » » » this.killerParts.ToggleName(false); |
| 21 | » » » this.LoadKillerPet(killerOutfit); | 29 | » » » this.LoadKillerPet(initData.killerOutfit); |
| 22 | » » } | 30 | » » } |
| 23 | » » if·(v | 31 | » » if·(initData.victimOutfit·!=·null·&&·this.victimParts) |
| 24 | » » { | 32 | » » { |
| 25 | » » » PlayerControl·playerControl2·=·PlayerControl.AllPlayerControls.Find((PlayerControl·p)·=>·p.PlayerId·==·vInfo.PlayerId); | ||
| 26 | » » » GameData.PlayerOutfit·victimOutfit·=·playerControl2.CurrentOutfit; | ||
| 27 | » » » this.victimHat·=·victimOutfit.HatId; | 33 | » » » this.victimHat·=·initData.victimOutfit.HatId; |
| 28 | » » » this.victimParts.SetBodyType( | 34 | » » » this.victimParts.SetBodyType(initData.victimBodyType); |
| 29 | » » » this.victimParts.UpdateFromPlayer | 35 | » » » this.victimParts.UpdateFromPlayerOutfit(initData.victimOutfit,·PlayerMaterial.MaskType.None,·false,·false,·delegate |
| 30 | » » » { | 36 | » » » { |
| 31 | » » » » this.LoadVictimSkin(victimOutfit); | 37 | » » » » this.LoadVictimSkin(initData.victimOutfit); |
| 32 | » » » },·false); | 38 | » » » },·false); |
| 39 | » » » this.victimParts.SetHatLeftFacingVictim(this.leftFacingVictim); | ||
| 33 | » » » this.victimParts.ToggleName(false); | 40 | » » » this.victimParts.ToggleName(false); |
| 34 | » » » this.LoadVictimPet(victimOutfit); | 41 | » » » this.LoadVictimPet(initData.victimOutfit); |
| 35 | » » } | 42 | » » } |
| 36 | » } | 43 | » } |
| 37 | 44 | ||
| 38 | » public·void·SetHatFloor() | 45 | » public·void·SetHatFloor() |
| 39 | » { | 46 | » { |
| 40 | » » HatData·hatById·=·DestroyableSingleton<HatManager>.Instance.GetHatById(this.victimHat); | 47 | » » HatData·hatById·=·DestroyableSingleton<HatManager>.Instance.GetHatById(this.victimHat); |
| 41 | » » if·(!hatById) | 48 | » » if·(!hatById) |
| 42 | » » { | 49 | » » { |
| 43 | » » » return; | 50 | » » » return; |
| 44 | » » } | 51 | » » } |
| 45 | » » this.victimParts.SetHatWithoutChangingColor(hatById); | 52 | » » this.victimParts.SetHatWithoutChangingColor(hatById); |
| 53 | » » this.victimParts.SetHatOnFloor(); | ||
| 54 | » } | ||
| 55 | |||
| 56 | » public·void·SetVisorFloor() | ||
| 57 | » { | ||
| 46 | » » this.victimParts.Set | 58 | » » this.victimParts.SetVisorOnFloor(); |
| 47 | » } | 59 | » } |
| 48 | 60 | ||
| 49 | » public·void·PlayKillSound() | 61 | » public·void·PlayKillSound() |
| 50 | » { | 62 | » { |
| 51 | » » if·(Constants.ShouldPlaySfx()) | 63 | » » if·(Constants.ShouldPlaySfx()) |
| 52 | » » { | 64 | » » { |
| 53 | » » » SoundManager.Instance.PlaySound(this.Sfx,·false,·1f,·null).volume·=·0.8f; | 65 | » » » SoundManager.Instance.PlaySound(this.Sfx,·false,·1f,·null).volume·=·0.8f; |
| Offset 119, 82 lines modified | Offset 131, 125 lines modified | ||
| 119 | » » » » } | 131 | » » » » } |
| 120 | » » » » yield·return·null; | 132 | » » » » yield·return·null; |
| 121 | » » » } | 133 | » » » } |
| 122 | » » } | 134 | » » } |
| 123 | » » yield·break; | 135 | » » yield·break; |
| 124 | » } | 136 | » } |
| 125 | 137 | ||
| 126 | » private·void·LoadVictimSkin( | 138 | » private·void·LoadVictimSkin(NetworkedPlayerInfo.PlayerOutfit·outfit) |
| 127 | » { | 139 | » { |
| 128 | » » Skin | 140 | » » SkinData·skinById·=·DestroyableSingleton<HatManager>.Instance.GetSkinById(outfit.SkinId); |
| 141 | » » if·(!skinById·||·skinById.IsEmpty) | ||
| 142 | » » { | ||
| 143 | » » » return; | ||
| 144 | » » } | ||
| 145 | » » SkinViewData·skinView·=·this.victimParts.GetSkinView(); | ||
| 129 | » » SpriteAnim·skinSpriteAnim·=·this.victimParts.GetSkinSpriteAnim(); | 146 | » » SpriteAnim·skinSpriteAnim·=·this.victimParts.GetSkinSpriteAnim(); |
| 130 | » » switch·(this.KillType) | 147 | » » switch·(this.KillType) |
| 131 | » » { | 148 | » » { |
| 132 | » » case·KillAnimType.Stab: | 149 | » » case·KillAnimType.Stab: |
| 133 | » » » skinSpriteAnim.Play(skin.KillStabVictim,·1f); | 150 | » » » skinSpriteAnim.Play(skinView.KillStabVictim,·1f); |
| 134 | » » » return; | 151 | » » » return; |
| 135 | » » case·KillAnimType.Tongue: | 152 | » » case·KillAnimType.Tongue: |
| 136 | » » » skinSpriteAnim.Play(skin.KillTongueVictim,·1f); | 153 | » » » skinSpriteAnim.Play(skinView.KillTongueVictim,·1f); |
| 137 | » » » return; | 154 | » » » return; |
| 138 | » » case·KillAnimType.Shoot: | 155 | » » case·KillAnimType.Shoot: |
| 139 | » » » skinSpriteAnim.Play(skin.KillShootVictim,·1f); | 156 | » » » skinSpriteAnim.Play(skinView.KillShootVictim,·1f); |
| 140 | » » » return; | 157 | » » » return; |
| 141 | » » case·KillAnimType.Neck: | 158 | » » case·KillAnimType.Neck: |
| 142 | » » » skinSpriteAnim.Play(skin.KillNeckVictim,·1f); | 159 | » » » skinSpriteAnim.Play(skinView.KillNeckVictim,·1f); |
| 143 | » » » return; | 160 | » » » return; |
| 144 | » » case·KillAnimType.RHM: | 161 | » » case·KillAnimType.RHM: |
| 145 | » » » skinSpriteAnim.Play(skin.KillRHMVictim,·1f); | 162 | » » » skinSpriteAnim.Play(skinView.KillRHMVictim,·1f); |
| 163 | » » » return; | ||
| 164 | » » case·KillAnimType.Werewolf_Slash: | ||
| 165 | » » » skinSpriteAnim.Play(skinView.IdleLeftAnim,·1f); | ||
| 146 | » » » return; | 166 | » » » return; |
| 147 | » » default: | 167 | » » default: |
| 148 | » » » return; | 168 | » » » return; |
| 149 | » » } | 169 | » » } |
| 150 | » } | 170 | » } |
| 151 | 171 | ||
| 152 | » private·void·LoadKillerSkin( | 172 | » private·void·LoadKillerSkin(NetworkedPlayerInfo.PlayerOutfit·outfit) |
| 153 | » { | 173 | » { |
| 154 | » » Skin | 174 | » » SkinData·skinById·=·DestroyableSingleton<HatManager>.Instance.GetSkinById(outfit.SkinId); |
| 175 | » » if·(!skinById·||·skinById.IsEmpty) | ||
| 176 | » » { | ||
| 177 | » » » return; | ||
| 178 | » » } | ||
| 179 | » » SkinViewData·skinView·=·this.killerParts.GetSkinView(); | ||
| 180 | » » SpriteAnim·skinSpriteAnim·=·this.killerParts.GetSkinSpriteAnim(); | ||
| 155 | » » switch·(this.KillType) | 181 | » » switch·(this.KillType) |
| 156 | » » { | 182 | » » { |
| 157 | » » case·KillAnimType.Stab: | 183 | » » case·KillAnimType.Stab: |
| 158 | » » » | 184 | » » » skinSpriteAnim.Play(skinView.KillStabImpostor,·1f); |
| 159 | » » » return; | 185 | » » » return; |
| 160 | » » case·KillAnimType.Tongue: | 186 | » » case·KillAnimType.Tongue: |
| 161 | » » » | 187 | » » » skinSpriteAnim.Play(skinView.KillTongueImpostor,·1f); |
| Max diff block lines reached; 3062/8526 bytes (35.91%) of diff not shown. | |||
| Offset 46, 14 lines modified | Offset 46, 36 lines modified | ||
| 46 | 46 | ||
| 47 | » public·static·readonly·Color·Brown·=·new·Color(0.72f,·0.43f,·0.11f); | 47 | » public·static·readonly·Color·Brown·=·new·Color(0.72f,·0.43f,·0.11f); |
| 48 | 48 | ||
| 49 | » public·static·readonly·Color·CrewmateBlue·=·new·Color32(140,·byte.MaxValue,·byte.MaxValue,·byte.MaxValue); | 49 | » public·static·readonly·Color·CrewmateBlue·=·new·Color32(140,·byte.MaxValue,·byte.MaxValue,·byte.MaxValue); |
| 50 | 50 | ||
| 51 | » public·static·readonly·Color·ImpostorRed·=·new·Color32(byte.MaxValue,·25,·25,·byte.MaxValue); | 51 | » public·static·readonly·Color·ImpostorRed·=·new·Color32(byte.MaxValue,·25,·25,·byte.MaxValue); |
| 52 | 52 | ||
| 53 | » public·static·readonly·Color·CrewmateRoleBlue·=·new·Color32(17,·135,·178,·byte.MaxValue); | ||
| 54 | |||
| 55 | » public·static·readonly·Color·CrewmateRoleHeaderBlue·=·new·Color32(120,·204,·236,·byte.MaxValue); | ||
| 56 | |||
| 57 | » public·static·readonly·Color·CrewmateRoleHeaderTextBlue·=·new·Color32(14,·91,·119,·byte.MaxValue); | ||
| 58 | |||
| 59 | » public·static·readonly·Color·CrewmateRoleHeaderDarkBlue·=·new·Color32(10,·87,·115,·byte.MaxValue); | ||
| 60 | |||
| 61 | » public·static·readonly·Color·CrewmateRoleHeaderVeryDarkBlue·=·new·Color32(10,·87,·115,·127); | ||
| 62 | |||
| 63 | » public·static·readonly·Color·CrewmateSettingChangeText·=·new·Color32(102,·171,·244,·byte.MaxValue); | ||
| 64 | |||
| 65 | » public·static·readonly·Color·ImpostorRoleRed·=·new·Color32(211,·35,·35,·byte.MaxValue); | ||
| 66 | |||
| 67 | » public·static·readonly·Color·ImpostorRoleHeaderRed·=·new·Color32(204,·83,·83,·byte.MaxValue); | ||
| 68 | |||
| 69 | » public·static·readonly·Color·ImpostorRoleHeaderTextRed·=·new·Color32(88,·35,·35,·byte.MaxValue); | ||
| 70 | |||
| 71 | » public·static·readonly·Color·ImpostorRoleHeaderDarkRed·=·new·Color32(137,·22,·22,·byte.MaxValue); | ||
| 72 | |||
| 73 | » public·static·readonly·Color·ImpostorRoleHeaderVeryDarkRed·=·new·Color32(137,·22,·22,·127); | ||
| 74 | |||
| 53 | » public·static·readonly·Color·CosmicubeCellUnlockedColor·=·new·Color(0.023529412f,·0.78431374f,·0.39215687f); | 75 | » public·static·readonly·Color·CosmicubeCellUnlockedColor·=·new·Color(0.023529412f,·0.78431374f,·0.39215687f); |
| 54 | 76 | ||
| 55 | » public·static·readonly·Color·CosmicubeCellLockedColor·=·new·Color(0.7019608f,·0.67058825f,·0.7176471f); | 77 | » public·static·readonly·Color·CosmicubeCellLockedColor·=·new·Color(0.7019608f,·0.67058825f,·0.7176471f); |
| 56 | 78 | ||
| 57 | » public·static·readonly·Color·CosmicubeQuality_NamePlate·=·new·Color32(73,·174,·217,·byte.MaxValue); | 79 | » public·static·readonly·Color·CosmicubeQuality_NamePlate·=·new·Color32(73,·174,·217,·byte.MaxValue); |
| 58 | 80 | ||
| 59 | » public·static·readonly·Color·CosmicubeQuality_Hat·=·new·Color32(225,·222,·0,·byte.MaxValue); | 81 | » public·static·readonly·Color·CosmicubeQuality_Hat·=·new·Color32(225,·222,·0,·byte.MaxValue); |
| Offset 140, 9 lines modified | Offset 162, 53 lines modified | ||
| 140 | » » Palette.FromHex(14586547), | 162 | » » Palette.FromHex(14586547), |
| 141 | » » Palette.FromHex(13810825), | 163 | » » Palette.FromHex(13810825), |
| 142 | » » Palette.FromHex(4609636), | 164 | » » Palette.FromHex(4609636), |
| 143 | » » Palette.FromHex(5325118), | 165 | » » Palette.FromHex(5325118), |
| 144 | » » Palette.FromHex(11813730) | 166 | » » Palette.FromHex(11813730) |
| 145 | » }; | 167 | » }; |
| 146 | 168 | ||
| 169 | » public·static·readonly·Color32[]·TextColors·=·new·Color32[] | ||
| 170 | » { | ||
| 171 | » » Palette.FromHex(12980497), | ||
| 172 | » » Palette.FromHex(3166207), | ||
| 173 | » » Palette.FromHex(1016620), | ||
| 174 | » » Palette.FromHex(15619260), | ||
| 175 | » » Palette.FromHex(16415747), | ||
| 176 | » » Palette.FromHex(16576084), | ||
| 177 | » » Palette.FromHex(0), | ||
| 178 | » » Palette.FromHex(16777215), | ||
| 179 | » » Palette.FromHex(8927470), | ||
| 180 | » » Palette.FromHex(10052905), | ||
| 181 | » » Palette.FromHex(3794140), | ||
| 182 | » » Palette.FromHex(5304117), | ||
| 183 | » » Palette.FromHex(12068436), | ||
| 184 | » » Palette.FromHex(13729702), | ||
| 185 | » » Palette.FromHex(16646078), | ||
| 186 | » » Palette.FromHex(9280945), | ||
| 187 | » » Palette.FromHex(9799796), | ||
| 188 | » » Palette.FromHex(13723489) | ||
| 189 | » }; | ||
| 190 | |||
| 191 | » public·static·readonly·Color32[]·TextOutlineColors·=·new·Color32[] | ||
| 192 | » { | ||
| 193 | » » Palette.FromHex(983040), | ||
| 194 | » » Palette.FromHex(983040), | ||
| 195 | » » Palette.FromHex(3335), | ||
| 196 | » » Palette.FromHex(2555941), | ||
| 197 | » » Palette.FromHex(983040), | ||
| 198 | » » Palette.FromHex(3152384), | ||
| 199 | » » Palette.FromHex(16777215), | ||
| 200 | » » Palette.FromHex(0), | ||
| 201 | » » Palette.FromHex(720911), | ||
| 202 | » » Palette.FromHex(985088), | ||
| 203 | » » Palette.FromHex(6682), | ||
| 204 | » » Palette.FromHex(464640), | ||
| 205 | » » Palette.FromHex(1703936), | ||
| 206 | » » Palette.FromHex(5445419), | ||
| 207 | » » Palette.FromHex(1248512), | ||
| 208 | » » Palette.FromHex(0), | ||
| 209 | » » Palette.FromHex(920064), | ||
| 210 | » » Palette.FromHex(3604492) | ||
| 211 | » }; | ||
| 212 | |||
| 147 | » public·static·readonly·Color32·VisorColor·=·new·Color32(149,·202,·220,·byte.MaxValue); | 213 | » public·static·readonly·Color32·VisorColor·=·new·Color32(149,·202,·220,·byte.MaxValue); |
| 148 | } | 214 | } |
| Offset 25, 18 lines modified | Offset 25, 22 lines modified | ||
| 25 | » { | 25 | » { |
| 26 | » » get | 26 | » » get |
| 27 | » » { | 27 | » » { |
| 28 | » » » return·this.OnRepeat; | 28 | » » » return·this.OnRepeat; |
| 29 | » » } | 29 | » » } |
| 30 | » } | 30 | » } |
| 31 | 31 | ||
| 32 | » private·void·Awake() | ||
| 33 | » { | ||
| 34 | » » this.SetPassiveButtonHoverStateInactive(); | ||
| 35 | » } | ||
| 36 | |||
| 32 | » protected·override·void·Start() | 37 | » protected·override·void·Start() |
| 33 | » { | 38 | » { |
| 34 | » » base.Start(); | 39 | » » base.Start(); |
| 35 | » » this.SetPassiveButtonHoverStateInactive(); | ||
| 36 | » } | 40 | » } |
| 37 | 41 | ||
| 38 | » protected·override·void·Update() | 42 | » protected·override·void·Update() |
| 39 | » { | 43 | » { |
| 40 | » » base.Update(); | 44 | » » base.Update(); |
| 41 | » » if·(this.HoldToUse·&&·this.beingHeldDown) | 45 | » » if·(this.HoldToUse·&&·this.beingHeldDown) |
| 42 | » » { | 46 | » » { |
| Offset 91, 14 lines modified | Offset 95, 15 lines modified | ||
| 91 | » » { | 95 | » » { |
| 92 | » » » return; | 96 | » » » return; |
| 93 | » » } | 97 | » » } |
| 94 | » » if·(this.ClickSound) | 98 | » » if·(this.ClickSound) |
| 95 | » » { | 99 | » » { |
| 96 | » » » SoundManager.Instance.PlaySound(this.ClickSound,·false,·1f,·null); | 100 | » » » SoundManager.Instance.PlaySound(this.ClickSound,·false,·1f,·null); |
| 97 | » » } | 101 | » » } |
| 102 | » » this.repeatTimer·=·0f; | ||
| 98 | » » this.OnClick.Invoke(); | 103 | » » this.OnClick.Invoke(); |
| 99 | » } | 104 | » } |
| 100 | 105 | ||
| 101 | » public·override·void·ReceiveRepeatDown() | 106 | » public·override·void·ReceiveRepeatDown() |
| 102 | » { | 107 | » { |
| 103 | » » if·(!base.enabled) | 108 | » » if·(!base.enabled) |
| 104 | » » { | 109 | » » { |
| Offset 184, 14 lines modified | Offset 189, 15 lines modified | ||
| 184 | » » » }); | 189 | » » » }); |
| 185 | » » } | 190 | » » } |
| 186 | » } | 191 | » } |
| 187 | 192 | ||
| 188 | » public·override·void·ReleaseButton() | 193 | » public·override·void·ReleaseButton() |
| 189 | » { | 194 | » { |
| 190 | » » this.totalHeldTime·=·0f; | 195 | » » this.totalHeldTime·=·0f; |
| 196 | » » this.repeatTimer·=·0f; | ||
| 191 | » } | 197 | » } |
| 192 | 198 | ||
| 193 | » public·override·void·ReceiveMouseOut() | 199 | » public·override·void·ReceiveMouseOut() |
| 194 | » { | 200 | » { |
| 195 | » » if·(!base.enabled) | 201 | » » if·(!base.enabled) |
| 196 | » » { | 202 | » » { |
| 197 | » » » return; | 203 | » » » return; |
| Offset 216, 14 lines modified | Offset 222, 26 lines modified | ||
| 216 | 222 | ||
| 217 | » private·void·SetPassiveButtonHoverStateActive() | 223 | » private·void·SetPassiveButtonHoverStateActive() |
| 218 | » { | 224 | » { |
| 219 | » » if·(!base.enabled) | 225 | » » if·(!base.enabled) |
| 220 | » » { | 226 | » » { |
| 221 | » » » return; | 227 | » » » return; |
| 222 | » » } | 228 | » » } |
| 229 | » » if·(this.selectedInactiveSprites·!=·null) | ||
| 230 | » » { | ||
| 231 | » » » this.selectedInactiveSprites.SetActive(false); | ||
| 232 | » » » if·(this.selectedSprites·!=·null·&&·this.selected) | ||
| 233 | » » » { | ||
| 234 | » » » » this.selectedSprites.SetActive(true); | ||
| 235 | » » » } | ||
| 236 | » » } | ||
| 237 | » » if·(this.selected) | ||
| 238 | » » { | ||
| 239 | » » » return; | ||
| 240 | » » } | ||
| 223 | » » if·(this.activeSprites·!=·null) | 241 | » » if·(this.activeSprites·!=·null) |
| 224 | » » { | 242 | » » { |
| 225 | » » » this.activeSprites.SetActive(true); | 243 | » » » this.activeSprites.SetActive(true); |
| 226 | » » } | 244 | » » } |
| 227 | » » if·(this.inactiveSprites·!=·null) | 245 | » » if·(this.inactiveSprites·!=·null) |
| 228 | » » { | 246 | » » { |
| 229 | » » » this.inactiveSprites.SetActive(false); | 247 | » » » this.inactiveSprites.SetActive(false); |
| Offset 240, 18 lines modified | Offset 258, 39 lines modified | ||
| 240 | 258 | ||
| 241 | » private·void·SetPassiveButtonHoverStateInactive() | 259 | » private·void·SetPassiveButtonHoverStateInactive() |
| 242 | » { | 260 | » { |
| 243 | » » if·(!base.enabled) | 261 | » » if·(!base.enabled) |
| 244 | » » { | 262 | » » { |
| 245 | » » » return; | 263 | » » » return; |
| 246 | » » } | 264 | » » } |
| 265 | » » if·(this.selectedInactiveSprites·!=·null·&&·this.selected) | ||
| 266 | » » { | ||
| 267 | » » » if·(this.selectedSprites·!=·null) | ||
| 268 | » » » { | ||
| 269 | » » » » this.selectedSprites.SetActive(false); | ||
| 270 | » » » } | ||
| 271 | » » » if·(this.inactiveSprites·!=·null) | ||
| 272 | » » » { | ||
| 273 | » » » » this.inactiveSprites.SetActive(false); | ||
| 274 | » » » } | ||
| 275 | » » » this.selectedInactiveSprites.SetActive(true); | ||
| 276 | » » » return; | ||
| 277 | » » } | ||
| 278 | » » if·(this.selected) | ||
| 279 | » » { | ||
| 280 | » » » return; | ||
| 281 | » » } | ||
| 247 | » » if·(this.activeSprites·!=·null) | 282 | » » if·(this.activeSprites·!=·null) |
| 248 | » » { | 283 | » » { |
| 249 | » » » this.activeSprites.SetActive(false); | 284 | » » » this.activeSprites.SetActive(false); |
| 250 | » » } | 285 | » » } |
| 286 | » » if·(this.selectedSprites·!=·null) | ||
| 287 | » » { | ||
| 288 | » » » this.selectedSprites.SetActive(false); | ||
| 289 | » » } | ||
| 251 | » » if·(this.inactiveSprites·!=·null) | 290 | » » if·(this.inactiveSprites·!=·null) |
| 252 | » » { | 291 | » » { |
| 253 | » » » this.inactiveSprites.SetActive(true); | 292 | » » » this.inactiveSprites.SetActive(true); |
| 254 | » » } | 293 | » » } |
| 255 | » » if·(this.disabledSprites·!=·null) | 294 | » » if·(this.disabledSprites·!=·null) |
| 256 | » » { | 295 | » » { |
| 257 | » » » this.disabledSprites.SetActive(false); | 296 | » » » this.disabledSprites.SetActive(false); |
| Offset 272, 20 lines modified | Offset 311, 70 lines modified | ||
| 272 | » » { | 311 | » » { |
| 273 | » » » this.inactiveSprites.SetActive(false); | 312 | » » » this.inactiveSprites.SetActive(false); |
| 274 | » » } | 313 | » » } |
| 275 | » » if·(this.disabledSprites·!=·null) | 314 | » » if·(this.disabledSprites·!=·null) |
| Max diff block lines reached; 2247/4752 bytes (47.29%) of diff not shown. | |||
| Offset 3, 43 lines modified | Offset 3, 53 lines modified | ||
| 3 | using·PowerTools; | 3 | using·PowerTools; |
| 4 | using·UnityEngine; | 4 | using·UnityEngine; |
| 5 | 5 | ||
| 6 | public·class·PbExileController·:·ExileController | 6 | public·class·PbExileController·:·ExileController |
| 7 | { | 7 | { |
| 8 | » protected·override·IEnumerator·Animate() | 8 | » protected·override·IEnumerator·Animate() |
| 9 | » { | 9 | » { |
| 10 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | ||
| 11 | » » { | ||
| 10 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false); | 12 | » » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false); |
| 13 | » » } | ||
| 11 | » » yield·return·Effects.Wait(0.75f); | 14 | » » yield·return·Effects.Wait(0.75f); |
| 12 | » » yield·return·Effects.All(new·IEnumerator[] | 15 | » » yield·return·Effects.All(new·IEnumerator[] |
| 13 | » » { | 16 | » » { |
| 14 | » » » this.PlayerFall(), | 17 | » » » this.PlayerFall(), |
| 15 | » » » this.PlayerSpin(), | 18 | » » » this.PlayerSpin(), |
| 16 | » » » this.HandleText(this.Duration·*·0.5f,·this.Duration·*·0.5f) | 19 | » » » this.HandleText(this.Duration·*·0.5f,·this.Duration·*·0.5f) |
| 17 | » » }); | 20 | » » }); |
| 18 | » » if·( | 21 | » » if·(this.initData.confirmImpostor) |
| 19 | » » { | 22 | » » { |
| 20 | » » » this.ImpostorText.gameObject.SetActive(true); | 23 | » » » this.ImpostorText.gameObject.SetActive(true); |
| 21 | » » } | 24 | » » } |
| 22 | » » yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f); | 25 | » » yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f); |
| 23 | » » yield·return·new·WaitForSeconds(0.5f); | 26 | » » yield·return·new·WaitForSeconds(0.5f); |
| 27 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | ||
| 28 | » » { | ||
| 24 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false); | 29 | » » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false); |
| 30 | » » } | ||
| 31 | » » else | ||
| 32 | » » { | ||
| 33 | » » » yield·return·Effects.Wait(0.2f); | ||
| 34 | » » } | ||
| 25 | » » if·(this.finalSinkCoroutine·!=·null) | 35 | » » if·(this.finalSinkCoroutine·!=·null) |
| 26 | » » { | 36 | » » { |
| 27 | » » » base.StopCoroutine(this.finalSinkCoroutine); | 37 | » » » base.StopCoroutine(this.finalSinkCoroutine); |
| 28 | » » } | 38 | » » } |
| 29 | » » base.WrapUp(); | 39 | » » base.WrapUp(); |
| 30 | » » yield·break; | 40 | » » yield·break; |
| 31 | » } | 41 | » } |
| 32 | 42 | ||
| 33 | » private·IEnumerator·PlayerFall() | 43 | » private·IEnumerator·PlayerFall() |
| 34 | » { | 44 | » { |
| 35 | » » float·num·=·Camera.main.orthographicSize·+·1f; | 45 | » » float·num·=·Camera.main.orthographicSize·+·1f; |
| 36 | » » Vector2·top·=·Vector2.up·*·num; | 46 | » » Vector2·top·=·Vector2.up·*·num; |
| 37 | » » Vector2·bottom·=·Vector2.down·*·2.81f; | 47 | » » Vector2·bottom·=·Vector2.down·*·2.81f; |
| 38 | » » bool·started·=·this. | 48 | » » bool·started·=·this.initData·==·null·||·this.initData.outfit·==·null; |
| 39 | » » float·d·=·this.Duration·/·1.8f; | 49 | » » float·d·=·this.Duration·/·1.8f; |
| 40 | » » for·(float·t·=·0f;·t·<=·d;·t·+=·Time.deltaTime) | 50 | » » for·(float·t·=·0f;·t·<=·d;·t·+=·Time.deltaTime) |
| 41 | » » { | 51 | » » { |
| 42 | » » » float·num2·=·t·/·d; | 52 | » » » float·num2·=·t·/·d; |
| 43 | » » » float·num3·=·this.LerpCurve.Evaluate(num2); | 53 | » » » float·num3·=·this.LerpCurve.Evaluate(num2); |
| 44 | » » » Vector2·vector·=·Vector2.Lerp(top,·bottom,·num3); | 54 | » » » Vector2·vector·=·Vector2.Lerp(top,·bottom,·num3); |
| 45 | » » » this.Player.transform.localPosition·=·vector; | 55 | » » » this.Player.transform.localPosition·=·vector; |
| Offset 64, 22 lines modified | Offset 74, 22 lines modified | ||
| 64 | » » for·(float·t·=·0f;·t·<=·d;·t·+=·Time.deltaTime) | 74 | » » for·(float·t·=·0f;·t·<=·d;·t·+=·Time.deltaTime) |
| 65 | » » { | 75 | » » { |
| 66 | » » » float·num2·=·t·/·d; | 76 | » » » float·num2·=·t·/·d; |
| 67 | » » » float·num3·=·(t·+·0.75f)·*·25f·/·Mathf.Exp(t·*·0.75f·+·1f); | 77 | » » » float·num3·=·(t·+·0.75f)·*·25f·/·Mathf.Exp(t·*·0.75f·+·1f); |
| 68 | » » » this.Player.transform.Rotate(new·Vector3(0f,·0f,·num3·*·Time.deltaTime·*·5f)); | 78 | » » » this.Player.transform.Rotate(new·Vector3(0f,·0f,·num3·*·Time.deltaTime·*·5f)); |
| 69 | » » » yield·return·null; | 79 | » » » yield·return·null; |
| 70 | » » } | 80 | » » } |
| 71 | » » if·(! | 81 | » » if·(!this.initData.confirmImpostor) |
| 72 | » » { | 82 | » » { |
| 73 | » » » yield·break; | 83 | » » » yield·break; |
| 74 | » » } | 84 | » » } |
| 75 | » » if·(this. | 85 | » » if·(this.initData·!=·null·&&·this.initData.outfit·!=·null) |
| 76 | » » { | 86 | » » { |
| 77 | » » » this.HandSlot.sprite·=·(this. | 87 | » » » this.HandSlot.sprite·=·(this.initData.isImpostor·?·this.GoodHand·:·this.BadHand); |
| 78 | » » » PlayerMaterial.SetColors(this. | 88 | » » » PlayerMaterial.SetColors(this.initData.outfit.ColorId,·this.HandSlot); |
| 79 | » » } | 89 | » » } |
| 80 | » » this.Player.transform.eulerAngles·=·new·Vector3(0f,·0f,·-10f); | 90 | » » this.Player.transform.eulerAngles·=·new·Vector3(0f,·0f,·-10f); |
| 81 | » » float·num4·=·this.Duration·/·4f; | 91 | » » float·num4·=·this.Duration·/·4f; |
| 82 | » » top.y·=·-1.78f; | 92 | » » top.y·=·-1.78f; |
| 83 | » » yield·return·Effects.Overlerp(num4,·delegate(float·p) | 93 | » » yield·return·Effects.Overlerp(num4,·delegate(float·p) |
| 84 | » » { | 94 | » » { |
| 85 | » » » this.Player.transform.localPosition·=·Vector2.LerpUnclamped(bottom,·top,·p); | 95 | » » » this.Player.transform.localPosition·=·Vector2.LerpUnclamped(bottom,·top,·p); |
| Offset 137, 14 lines modified | Offset 137, 22 lines modified | ||
| 137 | » { | 137 | » { |
| 138 | » » this.ForEachRenderer(true,·delegate(SpriteRenderer·x) | 138 | » » this.ForEachRenderer(true,·delegate(SpriteRenderer·x) |
| 139 | » » { | 139 | » » { |
| 140 | » » » PlayerMaterial.SetMaskLayerBasedOnLocalPlayer(x,·true); | 140 | » » » PlayerMaterial.SetMaskLayerBasedOnLocalPlayer(x,·true); |
| 141 | » » }); | 141 | » » }); |
| 142 | » } | 142 | » } |
| 143 | 143 | ||
| 144 | » public·void·SetAlpha(float·alpha) | ||
| 145 | » { | ||
| 146 | » » this.ForEachRenderer(true,·delegate(SpriteRenderer·x) | ||
| 147 | » » { | ||
| 148 | » » » x.color·=·x.color.SetAlpha(alpha); | ||
| 149 | » » }); | ||
| 150 | » } | ||
| 151 | |||
| 144 | » public·bool·HasCrewmateColorShader() | 152 | » public·bool·HasCrewmateColorShader() |
| 145 | » { | 153 | » { |
| 146 | » » SpriteRenderer[]·array·=·this.renderers; | 154 | » » SpriteRenderer[]·array·=·this.renderers; |
| 147 | » » for·(int·i·=·0;·i·<·array.Length;·i++) | 155 | » » for·(int·i·=·0;·i·<·array.Length;·i++) |
| 148 | » » { | 156 | » » { |
| 149 | » » » if·(array[i].sharedMaterial.shader.name.Contains("PlayerShader")) | 157 | » » » if·(array[i].sharedMaterial.shader.name.Contains("PlayerShader")) |
| 150 | » » » { | 158 | » » » { |
| Offset 216, 24 lines modified | Offset 224, 28 lines modified | ||
| 216 | » » { | 224 | » » { |
| 217 | » » » this.rigidbody.interpolation·=·RigidbodyInterpolation2D.Interpolate; | 225 | » » » this.rigidbody.interpolation·=·RigidbodyInterpolation2D.Interpolate; |
| 218 | » » } | 226 | » » } |
| 219 | » } | 227 | » } |
| 220 | 228 | ||
| 221 | » private·void·Update() | 229 | » private·void·Update() |
| 222 | » { | 230 | » { |
| 231 | » » if·(this.viewOnly) | ||
| 232 | » » { | ||
| 233 | » » » return; | ||
| 234 | » » } | ||
| 223 | » » if·(this.manualMoving) | 235 | » » if·(this.manualMoving) |
| 224 | » » { | 236 | » » { |
| 225 | » » » return; | 237 | » » » return; |
| 226 | » » } | 238 | » » } |
| 227 | » » if·(!this.TargetPlayer·||·this.beingPet) | 239 | » » if·(!this.TargetPlayer·||·this.beingPet) |
| 228 | » » { | 240 | » » { |
| 229 | » » » this.rigidbody.velocity·=·Vector2.zero; | 241 | » » » this.rigidbody.velocity·=·Vector2.zero; |
| 230 | » » » return; | 242 | » » » return; |
| 231 | » » } | 243 | » » } |
| 232 | » » if·(this.TargetPlayer.Data.IsDead) | 244 | » » if·(this.TargetPlayer·!=·null·&&·this.TargetPlayer.Data·!=·null·&&·this.TargetPlayer.Data.IsDead) |
| 233 | » » { | 245 | » » { |
| 234 | » » » base.transform.position·=·this.TargetPlayer.GetTruePosition(); | 246 | » » » base.transform.position·=·this.TargetPlayer.GetTruePosition(); |
| 235 | » » » this.SetMourning(); | 247 | » » » this.SetMourning(); |
| 236 | » » » return; | 248 | » » » return; |
| 237 | » » } | 249 | » » } |
| 238 | » » Vector2·truePosition·=·this.TargetPlayer.GetTruePosition(); | 250 | » » Vector2·truePosition·=·this.TargetPlayer.GetTruePosition(); |
| 239 | » » Vector2·truePosition2·=·this.GetTruePosition(); | 251 | » » Vector2·truePosition2·=·this.GetTruePosition(); |
| Offset 259, 15 lines modified | Offset 271, 15 lines modified | ||
| 259 | » » » vector·*=·0.7f; | 271 | » » » vector·*=·0.7f; |
| 260 | » » } | 272 | » » } |
| 261 | » » AnimationClip·currentAnimation·=·this.animator.GetCurrentAnimation(); | 273 | » » AnimationClip·currentAnimation·=·this.animator.GetCurrentAnimation(); |
| 262 | » » if·(vector.sqrMagnitude·>·0.01f) | 274 | » » if·(vector.sqrMagnitude·>·0.01f) |
| 263 | » » { | 275 | » » { |
| 264 | » » » if·(currentAnimation·!=·this.walkClip) | 276 | » » » if·(currentAnimation·!=·this.walkClip) |
| 265 | » » » { | 277 | » » » { |
| 266 | » » » » this. | 278 | » » » » this.StartWalkAnim(); |
| 267 | » » » } | 279 | » » » } |
| 268 | » » » if·(vector.x·<·-0.01f) | 280 | » » » if·(vector.x·<·-0.01f) |
| 269 | » » » { | 281 | » » » { |
| 270 | » » » » this.FlipX·=·true; | 282 | » » » » this.FlipX·=·true; |
| 271 | » » » } | 283 | » » » } |
| 272 | » » » else·if·(vector.x·>·0.01f) | 284 | » » » else·if·(vector.x·>·0.01f) |
| 273 | » » » { | 285 | » » » { |
| Offset 279, 14 lines modified | Offset 291, 18 lines modified | ||
| 279 | » » » this.animator.Play(this.idleClip,·1f); | 291 | » » » this.animator.Play(this.idleClip,·1f); |
| 280 | » » } | 292 | » » } |
| 281 | » » this.rigidbody.velocity·=·vector; | 293 | » » this.rigidbody.velocity·=·vector; |
| 282 | » } | 294 | » } |
| 283 | 295 | ||
| 284 | » private·void·LateUpdate() | 296 | » private·void·LateUpdate() |
| 285 | » { | 297 | » { |
| 298 | » » if·(this.viewOnly) | ||
| 299 | » » { | ||
| 300 | » » » return; | ||
| 301 | » » } | ||
| 286 | » » Vector3·localPosition·=·base.transform.localPosition; | 302 | » » Vector3·localPosition·=·base.transform.localPosition; |
| 287 | » » localPosition.z·=·(localPosition.y·+·this.yOffset)·/·1000f·+·0.0002f; | 303 | » » localPosition.z·=·(localPosition.y·+·this.yOffset)·/·1000f·+·0.0002f; |
| 288 | » » base.transform.localPosition·=·localPosition; | 304 | » » base.transform.localPosition·=·localPosition; |
| 289 | » } | 305 | » } |
| 290 | 306 | ||
| 291 | » public·void·SetGettingPet(bool·petting,·Vector2·petPos) | 307 | » public·void·SetGettingPet(bool·petting,·Vector2·petPos) |
| 292 | » { | 308 | » { |
| Offset 303, 14 lines modified | Offset 319, 25 lines modified | ||
| 303 | » } | 319 | » } |
| 304 | 320 | ||
| 305 | » public·void·StartPetAnim() | 321 | » public·void·StartPetAnim() |
| 306 | » { | 322 | » { |
| 307 | » » this.animator.Play(this.petClip,·1f); | 323 | » » this.animator.Play(this.petClip,·1f); |
| 308 | » } | 324 | » } |
| 309 | 325 | ||
| 326 | » public·void·StartWalkAnim() | ||
| 327 | » { | ||
| 328 | » » this.animator.Play(this.walkClip,·1f); | ||
| 329 | » } | ||
| 330 | |||
| 331 | » public·void·ToggleViewOnly(bool·value) | ||
| 332 | » { | ||
| 333 | » » this.viewOnly·=·value; | ||
| 334 | » » global::Logger.GlobalInstance.Info("[PetBehaviour]·Setting·Pet·'"·+·base.gameObject.name·+·"'·viewOnly·to·"·+·value.ToString().ToUpper(),·null); | ||
| 335 | » } | ||
| 336 | |||
| 310 | » private·Vector2·GetTruePosition() | 337 | » private·Vector2·GetTruePosition() |
| 311 | » { | 338 | » { |
| 312 | » » return·base.transform.position·+·this.collider.offset·*·0.7f; | 339 | » » return·base.transform.position·+·this.collider.offset·*·0.7f; |
| 313 | » } | 340 | » } |
| 314 | 341 | ||
| 315 | » private·void·ForEachRenderer(bool·includeShadows,·Action<SpriteRenderer>·action) | 342 | » private·void·ForEachRenderer(bool·includeShadows,·Action<SpriteRenderer>·action) |
| 316 | » { | 343 | » { |
| Offset 343, 15 lines modified | Offset 370, 15 lines modified | ||
| 343 | 370 | ||
| 344 | » private·IEnumerator·WalkPetTo(Vector2·worldPos,·float·speed,·float·tolerance·=·0.01f) | 371 | » private·IEnumerator·WalkPetTo(Vector2·worldPos,·float·speed,·float·tolerance·=·0.01f) |
| 345 | » { | 372 | » { |
| 346 | » » this.manualMoving·=·true; | 373 | » » this.manualMoving·=·true; |
| 347 | » » Rigidbody2D·body·=·this.rigidbody; | 374 | » » Rigidbody2D·body·=·this.rigidbody; |
| 348 | » » if·(this.animator.GetCurrentAnimation()·!=·this.walkClip) | 375 | » » if·(this.animator.GetCurrentAnimation()·!=·this.walkClip) |
| 349 | » » { | 376 | » » { |
| 350 | » » » this. | 377 | » » » this.StartWalkAnim(); |
| 351 | » » } | 378 | » » } |
| 352 | » » Vector2·del·=·worldPos·-·base.transform.position; | 379 | » » Vector2·del·=·worldPos·-·base.transform.position; |
| 353 | » » while·(del.sqrMagnitude·>·tolerance) | 380 | » » while·(del.sqrMagnitude·>·tolerance) |
| 354 | » » { | 381 | » » { |
| 355 | » » » Mathf.Clamp(del.magnitude·*·2f,·0.05f,·1f); | 382 | » » » Mathf.Clamp(del.magnitude·*·2f,·0.05f,·1f); |
| 356 | » » » body.velocity·=·del.normalized·*·speed; | 383 | » » » body.velocity·=·del.normalized·*·speed; |
| Max diff block lines reached; 1013/4343 bytes (23.32%) of diff not shown. | |||
| Offset 1, 11 lines modified | Offset 1, 9 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections; | ||
| 3 | using·Innersloth.Assets; | 2 | using·Innersloth.Assets; |
| 4 | using·UnityEngine; | ||
| 5 | using·UnityEngine.AddressableAssets; | 3 | using·UnityEngine.AddressableAssets; |
| 6 | 4 | ||
| 7 | public·class·PetData·:·CosmeticData,·IAddressableAssetProvider<PetBehaviour> | 5 | public·class·PetData·:·CosmeticData,·IAddressableAssetProvider<PetBehaviour> |
| 8 | { | 6 | { |
| 9 | » public·bool·IsEmpty | 7 | » public·bool·IsEmpty |
| 10 | » { | 8 | » { |
| 11 | » » get | 9 | » » get |
| Offset 20, 22 lines modified | Offset 18, 14 lines modified | ||
| 20 | » } | 18 | » } |
| 21 | 19 | ||
| 22 | » public·AssetReference·GetAssetReference() | 20 | » public·AssetReference·GetAssetReference() |
| 23 | » { | 21 | » { |
| 24 | » » return·this.PetPrefabRef; | 22 | » » return·this.PetPrefabRef; |
| 25 | » } | 23 | » } |
| 26 | 24 | ||
| 27 | » public·override·IEnumerator·CoLoadIcon(Action<Sprite,·AddressableAsset>·onLoaded) | ||
| 28 | » { | ||
| 29 | » » AddressableAsset<PetBehaviour>·asset·=·this.CreateAddressableAsset(); | ||
| 30 | » » yield·return·asset.CoLoadAsync(null); | ||
| 31 | » » onLoaded(this.SpritePreview,·asset); | ||
| 32 | » » yield·break; | ||
| 33 | » } | ||
| 34 | |||
| 35 | » public·override·string·GetItemCategory() | 25 | » public·override·string·GetItemCategory() |
| 36 | » { | 26 | » { |
| 37 | » » return·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.PlayerPet,·Array.Empty<object>()); | 27 | » » return·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.PlayerPet,·Array.Empty<object>()); |
| 38 | » } | 28 | » } |
| 39 | 29 | ||
| 40 | » public·override·void·PreviewOnPlayer(PoolablePlayer·p,·int·colorId) | 30 | » public·override·void·PreviewOnPlayer(PoolablePlayer·p,·int·colorId) |
| 41 | » { | 31 | » { |
| Offset 20, 15 lines modified | Offset 20, 15 lines modified | ||
| 20 | » » } | 20 | » » } |
| 21 | » » Vector2·vector2·=·main.WorldToViewportPoint(this.target); | 21 | » » Vector2·vector2·=·main.WorldToViewportPoint(this.target); |
| 22 | » » if·(this.AmSeeker·&&·base.Between(vector2.x,·0f,·1f)·&&·base.Between(vector2.y,·0f,·1f)) | 22 | » » if·(this.AmSeeker·&&·base.Between(vector2.x,·0f,·1f)·&&·base.Between(vector2.y,·0f,·1f)) |
| 23 | » » { | 23 | » » { |
| 24 | » » » this.CloseBehaviour(vector,·num); | 24 | » » » this.CloseBehaviour(vector,·num); |
| 25 | » » » return; | 25 | » » » return; |
| 26 | » » } | 26 | » » } |
| 27 | » » | 27 | » » this.DistancedBehaviour(vector2,·vector,·num,·main); |
| 28 | » } | 28 | » } |
| 29 | 29 | ||
| 30 | » protected·override·void·CloseBehaviour(Vector2·del,·float·delLen) | 30 | » protected·override·void·CloseBehaviour(Vector2·del,·float·delLen) |
| 31 | » { | 31 | » { |
| 32 | » » base.transform.position·=·this.target; | 32 | » » base.transform.position·=·this.target; |
| 33 | » » float·num·=·Mathf.Clamp(delLen,·0f,·this.MaxScale); | 33 | » » float·num·=·Mathf.Clamp(delLen,·0f,·this.MaxScale); |
| 34 | » » base.transform.localScale·=·new·Vector3(num,·num,·num); | 34 | » » base.transform.localScale·=·new·Vector3(num,·num,·num); |
| Offset 8, 13 lines modified | Offset 8, 28 lines modified | ||
| 8 | » { | 8 | » { |
| 9 | » » if·(AmongUsClient.Instance) | 9 | » » if·(AmongUsClient.Instance) |
| 10 | » » { | 10 | » » { |
| 11 | » » » if·(AmongUsClient.Instance.NetworkMode·==·NetworkModes.FreePlay) | 11 | » » » if·(AmongUsClient.Instance.NetworkMode·==·NetworkModes.FreePlay) |
| 12 | » » » { | 12 | » » » { |
| 13 | » » » » base.gameObject.SetActive(false); | 13 | » » » » base.gameObject.SetActive(false); |
| 14 | » » » } | 14 | » » » } |
| 15 | » » » if·(AmongUsClient.Instance.IsGameStarted) | ||
| 16 | » » » { | ||
| 17 | » » » » this.aspectPosition.DistanceFromEdge·=·this.gamePos; | ||
| 18 | » » » } | ||
| 19 | » » » else | ||
| 20 | » » » { | ||
| 21 | » » » » this.aspectPosition.DistanceFromEdge·=·this.lobbyPos; | ||
| 22 | » » » } | ||
| 15 | » » » this.text.text·=·string.Format("P | 23 | » » » this.text.text·=·string.Format("PING:·<b>{0}·ms</b>",·AmongUsClient.Instance.Ping); |
| 16 | » » } | 24 | » » } |
| 17 | » } | 25 | » } |
| 18 | 26 | ||
| 19 | » public·TextMeshPro·text; | 27 | » public·TextMeshPro·text; |
| 28 | |||
| 29 | » [SerializeField] | ||
| 30 | » private·AspectPosition·aspectPosition; | ||
| 31 | |||
| 32 | » private·Vector3·lobbyPos·=·new·Vector3(-0.21f,·0.65f,·0f); | ||
| 33 | |||
| 34 | » private·Vector3·gamePos·=·new·Vector3(-0.21f,·0.32f,·0f); | ||
| 20 | } | 35 | } |
| Offset 176, 16 lines modified | Offset 176, 16 lines modified | ||
| 176 | » private·Sprite·openHand; | 176 | » private·Sprite·openHand; |
| 177 | 177 | ||
| 178 | » [SerializeField] | 178 | » [SerializeField] |
| 179 | » private·Sprite·closeHand; | 179 | » private·Sprite·closeHand; |
| 180 | 180 | ||
| 181 | » private·readonly·Controller·controller·=·new·Controller(); | 181 | » private·readonly·Controller·controller·=·new·Controller(); |
| 182 | 182 | ||
| 183 | » [Header("Audio")] | ||
| 184 | » [SerializeField] | 183 | » [SerializeField] |
| 184 | » [Header("Audio")] | ||
| 185 | » private·AudioClip[]·pickUpPartSfx; | 185 | » private·AudioClip[]·pickUpPartSfx; |
| 186 | 186 | ||
| 187 | » [SerializeField] | 187 | » [SerializeField] |
| 188 | » private·AudioClip[]·resetPartSfx; | 188 | » private·AudioClip[]·resetPartSfx; |
| 189 | 189 | ||
| 190 | » [SerializeField] | 190 | » [SerializeField] |
| 191 | » private·AudioClip[]·scrapOldPartSfx; | 191 | » private·AudioClip[]·scrapOldPartSfx; |
| Offset 23, 19 lines modified | Offset 23, 19 lines modified | ||
| 23 | » { | 23 | » { |
| 24 | » » get | 24 | » » get |
| 25 | » » { | 25 | » » { |
| 26 | » » » return·ImageNames.UseButton; | 26 | » » » return·ImageNames.UseButton; |
| 27 | » » } | 27 | » » } |
| 28 | » } | 28 | » } |
| 29 | 29 | ||
| 30 | » public·float·CanUse( | 30 | » public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse) |
| 31 | » { | 31 | » { |
| 32 | » » float·num·=·float.MaxValue; | 32 | » » float·num·=·float.MaxValue; |
| 33 | » » PlayerControl·@object·=·pc.Object; | 33 | » » PlayerControl·@object·=·pc.Object; |
| 34 | » » couldUse·=·!pc.IsDead·&&·@object.CanMove·&&·!this.Platform.InUse·&&·Vector2.Distance(this.Platform.transform.position,·base.transform.position)·<·2f; | 34 | » » couldUse·=·!pc.IsDead·&&·@object.CanMove·&&·!this.Platform.InUse·&&·Vector2.Distance(this.Platform.transform.position,·base.transform.position)·<·2f·&&·pc.Role.CanUse(this); |
| 35 | » » canUse·=·couldUse; | 35 | » » canUse·=·couldUse; |
| 36 | » » if·(canUse) | 36 | » » if·(canUse) |
| 37 | » » { | 37 | » » { |
| 38 | » » » Vector2·truePosition·=·@object.GetTruePosition(); | 38 | » » » Vector2·truePosition·=·@object.GetTruePosition(); |
| 39 | » » » Vector3·position·=·base.transform.position; | 39 | » » » Vector3·position·=·base.transform.position; |
| 40 | » » » num·=·Vector2.Distance(truePosition,·position); | 40 | » » » num·=·Vector2.Distance(truePosition,·position); |
| 41 | » » » canUse·&=·num·<=·this.UsableDistance·&&·!PhysicsHelpers.AnythingBetween(truePosition,·position,·Constants.ShipOnlyMask,·false); | 41 | » » » canUse·&=·num·<=·this.UsableDistance·&&·!PhysicsHelpers.AnythingBetween(truePosition,·position,·Constants.ShipOnlyMask,·false); |
| Offset 247, 16 lines modified | Offset 247, 16 lines modified | ||
| 247 | 247 | ||
| 248 | » [SerializeField] | 248 | » [SerializeField] |
| 249 | » private·SpriteRenderer·glowSpriteRenderer; | 249 | » private·SpriteRenderer·glowSpriteRenderer; |
| 250 | 250 | ||
| 251 | » [SerializeField] | 251 | » [SerializeField] |
| 252 | » private·List<PlayerAnimationGroup>·animationGroups; | 252 | » private·List<PlayerAnimationGroup>·animationGroups; |
| 253 | 253 | ||
| 254 | » [Header("Med·Scan")] | ||
| 255 | » [SerializeField] | 254 | » [SerializeField] |
| 255 | » [Header("Med·Scan")] | ||
| 256 | » private·SpriteAnim[]·scannerAnims; | 256 | » private·SpriteAnim[]·scannerAnims; |
| 257 | 257 | ||
| 258 | » [SerializeField] | 258 | » [SerializeField] |
| 259 | » private·SpriteRenderer[]·scannersImages; | 259 | » private·SpriteRenderer[]·scannersImages; |
| 260 | 260 | ||
| 261 | » private·PlayerAnimationGroup·group; | 261 | » private·PlayerAnimationGroup·group; |
| 262 | 262 | ||
| Offset 109, 15 lines modified | Offset 109, 15 lines modified | ||
| 109 | » private·static·readonly·Dictionary<PlayerBodyTypes,·VisorOptions>·CustomVisorOptions·=·new·Dictionary<PlayerBodyTypes,·VisorOptions> | 109 | » private·static·readonly·Dictionary<PlayerBodyTypes,·VisorOptions>·CustomVisorOptions·=·new·Dictionary<PlayerBodyTypes,·VisorOptions> |
| 110 | » { | 110 | » { |
| 111 | » » { | 111 | » » { |
| 112 | » » » PlayerBodyTypes.Normal, | 112 | » » » PlayerBodyTypes.Normal, |
| 113 | » » » new·VisorOptions | 113 | » » » new·VisorOptions |
| 114 | » » » { | 114 | » » » { |
| 115 | » » » » Enabled·=·true, | 115 | » » » » Enabled·=·true, |
| 116 | » » » » HideDuringClimb·=· | 116 | » » » » HideDuringClimb·=·false |
| 117 | » » » } | 117 | » » » } |
| 118 | » » }, | 118 | » » }, |
| 119 | » » { | 119 | » » { |
| 120 | » » » PlayerBodyTypes.Long, | 120 | » » » PlayerBodyTypes.Long, |
| 121 | » » » new·VisorOptions | 121 | » » » new·VisorOptions |
| 122 | » » » { | 122 | » » » { |
| 123 | » » » » Enabled·=·true, | 123 | » » » » Enabled·=·true, |
| Offset 125, 15 lines modified | Offset 125, 15 lines modified | ||
| 125 | » » » } | 125 | » » » } |
| 126 | » » }, | 126 | » » }, |
| 127 | » » { | 127 | » » { |
| 128 | » » » PlayerBodyTypes.Horse, | 128 | » » » PlayerBodyTypes.Horse, |
| 129 | » » » new·VisorOptions | 129 | » » » new·VisorOptions |
| 130 | » » » { | 130 | » » » { |
| 131 | » » » » Enabled·=·true, | 131 | » » » » Enabled·=·true, |
| 132 | » » » » HideDuringClimb·=· | 132 | » » » » HideDuringClimb·=·false |
| 133 | » » » } | 133 | » » » } |
| 134 | » » }, | 134 | » » }, |
| 135 | » » { | 135 | » » { |
| 136 | » » » PlayerBodyTypes.Seeker, | 136 | » » » PlayerBodyTypes.Seeker, |
| 137 | » » » new·VisorOptions | 137 | » » » new·VisorOptions |
| 138 | » » » { | 138 | » » » { |
| 139 | » » » » Enabled·=·false, | 139 | » » » » Enabled·=·false, |
| Offset 109, 22 lines modified | Offset 109, 23 lines modified | ||
| 109 | » » » this.CompleteTask(idx); | 109 | » » » this.CompleteTask(idx); |
| 110 | » » } | 110 | » » } |
| 111 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·1,·SendOption.Reliable); | 111 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·1,·SendOption.Reliable); |
| 112 | » » messageWriter.WritePacked(idx); | 112 | » » messageWriter.WritePacked(idx); |
| 113 | » » messageWriter.EndMessage(); | 113 | » » messageWriter.EndMessage(); |
| 114 | » } | 114 | » } |
| 115 | 115 | ||
| 116 | » public·void·RpcSetRole(RoleTypes·roleType) | 116 | » public·void·RpcSetRole(RoleTypes·roleType,·bool·canOverrideRole·=·false) |
| 117 | » { | 117 | » { |
| 118 | » » if·(AmongUsClient.Instance.AmClient) | 118 | » » if·(AmongUsClient.Instance.AmClient) |
| 119 | » » { | 119 | » » { |
| 120 | » » » this.SetRole(roleType); | 120 | » » » base.StartCoroutine(this.CoSetRole(roleType,·canOverrideRole)); |
| 121 | » » } | 121 | » » } |
| 122 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·44,·SendOption.Reliable); | 122 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·44,·SendOption.Reliable); |
| 123 | » » messageWriter.Write((ushort)roleType); | 123 | » » messageWriter.Write((ushort)roleType); |
| 124 | » » messageWriter.Write(canOverrideRole); | ||
| 124 | » » messageWriter.EndMessage(); | 125 | » » messageWriter.EndMessage(); |
| 125 | » } | 126 | » } |
| 126 | 127 | ||
| 127 | » public·void·CmdCheckName(string·name) | 128 | » public·void·CmdCheckName(string·name) |
| 128 | » { | 129 | » { |
| 129 | » » if·(AmongUsClient.Instance.AmHost) | 130 | » » if·(AmongUsClient.Instance.AmHost) |
| 130 | » » { | 131 | » » { |
| Offset 147, 111 lines modified | Offset 148, 117 lines modified | ||
| 147 | » » messageWriter.EndMessage(); | 148 | » » messageWriter.EndMessage(); |
| 148 | » } | 149 | » } |
| 149 | 150 | ||
| 150 | » public·void·RpcSetVisor(string·visorId) | 151 | » public·void·RpcSetVisor(string·visorId) |
| 151 | » { | 152 | » { |
| 152 | » » if·(AmongUsClient.Instance.AmClient) | 153 | » » if·(AmongUsClient.Instance.AmClient) |
| 153 | » » { | 154 | » » { |
| 154 | » » » | 155 | » » » NetworkedPlayerInfo·data·=·this.Data; |
| 155 | » » » int?·num; | 156 | » » » int?·num; |
| 156 | » » » if·(data·==·null) | 157 | » » » if·(data·==·null) |
| 157 | » » » { | 158 | » » » { |
| 158 | » » » » num·=·null; | 159 | » » » » num·=·null; |
| 159 | » » » } | 160 | » » » } |
| 160 | » » » else | 161 | » » » else |
| 161 | » » » { | 162 | » » » { |
| 162 | » » » » | 163 | » » » » NetworkedPlayerInfo.PlayerOutfit·defaultOutfit·=·data.DefaultOutfit; |
| 163 | » » » » num·=·((defaultOutfit·!=·null)·?·new·int?(defaultOutfit.ColorId)·:·null); | 164 | » » » » num·=·((defaultOutfit·!=·null)·?·new·int?(defaultOutfit.ColorId)·:·null); |
| 164 | » » » } | 165 | » » » } |
| 165 | » » » int?·num2·=·num; | 166 | » » » int?·num2·=·num; |
| 166 | » » » int·valueOrDefault·=·num2.GetValueOrDefault(); | 167 | » » » int·valueOrDefault·=·num2.GetValueOrDefault(); |
| 167 | » » » this.SetVisor(visorId,·valueOrDefault); | 168 | » » » this.SetVisor(visorId,·valueOrDefault); |
| 168 | » » } | 169 | » » } |
| 169 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·42,·SendOption.Reliable); | 170 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·42,·SendOption.Reliable); |
| 170 | » » messageWriter.Write(visorId); | 171 | » » messageWriter.Write(visorId); |
| 172 | » » messageWriter.Write(this.GetNextRpcSequenceId(RpcCalls.SetVisorStr)); | ||
| 171 | » » messageWriter.EndMessage(); | 173 | » » messageWriter.EndMessage(); |
| 172 | » } | 174 | » } |
| 173 | 175 | ||
| 174 | » public·void·RpcSetNamePlate(string·namePlateId) | 176 | » public·void·RpcSetNamePlate(string·namePlateId) |
| 175 | » { | 177 | » { |
| 176 | » » if·(AmongUsClient.Instance.AmClient) | 178 | » » if·(AmongUsClient.Instance.AmClient) |
| 177 | » » { | 179 | » » { |
| 178 | » » » this.SetNamePlate(namePlateId); | 180 | » » » this.SetNamePlate(namePlateId); |
| 179 | » » } | 181 | » » } |
| 180 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·43,·SendOption.Reliable); | 182 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·43,·SendOption.Reliable); |
| 181 | » » messageWriter.Write(namePlateId); | 183 | » » messageWriter.Write(namePlateId); |
| 184 | » » messageWriter.Write(this.GetNextRpcSequenceId(RpcCalls.SetNamePlateStr)); | ||
| 182 | » » messageWriter.EndMessage(); | 185 | » » messageWriter.EndMessage(); |
| 183 | » } | 186 | » } |
| 184 | 187 | ||
| 185 | » public·void·RpcSetSkin(string·skinId) | 188 | » public·void·RpcSetSkin(string·skinId) |
| 186 | » { | 189 | » { |
| 187 | » » if·(AmongUsClient.Instance.AmClient) | 190 | » » if·(AmongUsClient.Instance.AmClient) |
| 188 | » » { | 191 | » » { |
| 189 | » » » | 192 | » » » NetworkedPlayerInfo·data·=·this.Data; |
| 190 | » » » int?·num; | 193 | » » » int?·num; |
| 191 | » » » if·(data·==·null) | 194 | » » » if·(data·==·null) |
| 192 | » » » { | 195 | » » » { |
| 193 | » » » » num·=·null; | 196 | » » » » num·=·null; |
| 194 | » » » } | 197 | » » » } |
| 195 | » » » else | 198 | » » » else |
| 196 | » » » { | 199 | » » » { |
| 197 | » » » » | 200 | » » » » NetworkedPlayerInfo.PlayerOutfit·defaultOutfit·=·data.DefaultOutfit; |
| 198 | » » » » num·=·((defaultOutfit·!=·null)·?·new·int?(defaultOutfit.ColorId)·:·null); | 201 | » » » » num·=·((defaultOutfit·!=·null)·?·new·int?(defaultOutfit.ColorId)·:·null); |
| 199 | » » » } | 202 | » » » } |
| 200 | » » » int?·num2·=·num; | 203 | » » » int?·num2·=·num; |
| 201 | » » » int·valueOrDefault·=·num2.GetValueOrDefault(); | 204 | » » » int·valueOrDefault·=·num2.GetValueOrDefault(); |
| 202 | » » » this.SetSkin(skinId,·valueOrDefault); | 205 | » » » this.SetSkin(skinId,·valueOrDefault); |
| 203 | » » } | 206 | » » } |
| 204 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·40,·SendOption.Reliable); | 207 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·40,·SendOption.Reliable); |
| 205 | » » messageWriter.Write(skinId); | 208 | » » messageWriter.Write(skinId); |
| 209 | » » messageWriter.Write(this.GetNextRpcSequenceId(RpcCalls.SetSkinStr)); | ||
| 206 | » » messageWriter.EndMessage(); | 210 | » » messageWriter.EndMessage(); |
| 207 | » } | 211 | » } |
| 208 | 212 | ||
| 209 | » public·void·RpcSetHat(string·hatId) | 213 | » public·void·RpcSetHat(string·hatId) |
| 210 | » { | 214 | » { |
| 211 | » » if·(AmongUsClient.Instance.AmClient) | 215 | » » if·(AmongUsClient.Instance.AmClient) |
| 212 | » » { | 216 | » » { |
| 213 | » » » | 217 | » » » NetworkedPlayerInfo·data·=·this.Data; |
| 214 | » » » int?·num; | 218 | » » » int?·num; |
| 215 | » » » if·(data·==·null) | 219 | » » » if·(data·==·null) |
| 216 | » » » { | 220 | » » » { |
| 217 | » » » » num·=·null; | 221 | » » » » num·=·null; |
| 218 | » » » } | 222 | » » » } |
| 219 | » » » else | 223 | » » » else |
| 220 | » » » { | 224 | » » » { |
| 221 | » » » » | 225 | » » » » NetworkedPlayerInfo.PlayerOutfit·defaultOutfit·=·data.DefaultOutfit; |
| 222 | » » » » num·=·((defaultOutfit·!=·null)·?·new·int?(defaultOutfit.ColorId)·:·null); | 226 | » » » » num·=·((defaultOutfit·!=·null)·?·new·int?(defaultOutfit.ColorId)·:·null); |
| 223 | » » » } | 227 | » » » } |
| 224 | » » » int?·num2·=·num; | 228 | » » » int?·num2·=·num; |
| 225 | » » » int·valueOrDefault·=·num2.GetValueOrDefault(); | 229 | » » » int·valueOrDefault·=·num2.GetValueOrDefault(); |
| 226 | » » » this.SetHat(hatId,·valueOrDefault); | 230 | » » » this.SetHat(hatId,·valueOrDefault); |
| 227 | » » } | 231 | » » } |
| 228 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·39,·SendOption.Reliable); | 232 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·39,·SendOption.Reliable); |
| 229 | » » messageWriter.Write(hatId); | 233 | » » messageWriter.Write(hatId); |
| 234 | » » messageWriter.Write(this.GetNextRpcSequenceId(RpcCalls.SetHatStr)); | ||
| 230 | » » messageWriter.EndMessage(); | 235 | » » messageWriter.EndMessage(); |
| 231 | » } | 236 | » } |
| 232 | 237 | ||
| 233 | » public·void·RpcSetPet(string·petId) | 238 | » public·void·RpcSetPet(string·petId) |
| 234 | » { | 239 | » { |
| 235 | » » if·(AmongUsClient.Instance.AmClient) | 240 | » » if·(AmongUsClient.Instance.AmClient) |
| 236 | » » { | 241 | » » { |
| 237 | » » » this.SetPet(petId); | 242 | » » » this.SetPet(petId); |
| 238 | » » } | 243 | » » } |
| 239 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·41,·SendOption.Reliable); | 244 | » » MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·41,·SendOption.Reliable); |
| 240 | » » messageWriter.Write(petId); | 245 | » » messageWriter.Write(petId); |
| 246 | » » messageWriter.Write(this.GetNextRpcSequenceId(RpcCalls.SetPetStr)); | ||
| 241 | » » messageWriter.EndMessage(); | 247 | » » messageWriter.EndMessage(); |
| 242 | » } | 248 | » } |
| 243 | 249 | ||
| 244 | » public·void·RpcSetName(string·name) | 250 | » public·void·RpcSetName(string·name) |
| Max diff block lines reached; 56016/60329 bytes (92.85%) of diff not shown. | |||
| Offset 283, 14 lines modified | Offset 283, 16 lines modified | ||
| 283 | 283 | ||
| 284 | » public·GameObject·equippedText; | 284 | » public·GameObject·equippedText; |
| 285 | 285 | ||
| 286 | » public·GameObject·nameplateMaskArea; | 286 | » public·GameObject·nameplateMaskArea; |
| 287 | 287 | ||
| 288 | » public·GameObject·cubeArea; | 288 | » public·GameObject·cubeArea; |
| 289 | 289 | ||
| 290 | » public·GameObject·cosmicubeMenu; | ||
| 291 | |||
| 290 | » public·TextMeshPro·itemName; | 292 | » public·TextMeshPro·itemName; |
| 291 | 293 | ||
| 292 | » public·Action·OnClose; | 294 | » public·Action·OnClose; |
| 293 | 295 | ||
| 294 | » public·Action·OnOpen; | 296 | » public·Action·OnOpen; |
| 295 | 297 | ||
| 296 | » public·GameObject·AprilFoolText; | 298 | » public·GameObject·AprilFoolText; |
| Offset 1, 15 lines modified | Offset 1, 15 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·InnerNet; | 2 | using·InnerNet; |
| 3 | using·TMPro; | 3 | using·TMPro; |
| 4 | using·UnityEngine; | 4 | using·UnityEngine; |
| 5 | 5 | ||
| 6 | public·class·PlayerIdentifierButton·:·PoolableBehavior | 6 | public·class·PlayerIdentifierButton·:·PoolableBehavior |
| 7 | { | 7 | { |
| 8 | » public·void·Populate( | 8 | » public·void·Populate(NetworkedPlayerInfo·player) |
| 9 | » { | 9 | » { |
| 10 | » » this.NameText.text·=·player.PlayerName; | 10 | » » this.NameText.text·=·player.PlayerName; |
| 11 | » » this.SetTargetPlayerId(player.PlayerId); | 11 | » » this.SetTargetPlayerId(player.PlayerId); |
| 12 | » » this.PlayerPreview.UpdateFromEitherPlayerDataOrCache(player,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.SimpleUI,·false,·null); | 12 | » » this.PlayerPreview.UpdateFromEitherPlayerDataOrCache(player,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.SimpleUI,·false,·null); |
| 13 | » » this.PlayerPreview.ToggleName(false); | 13 | » » this.PlayerPreview.ToggleName(false); |
| 14 | » } | 14 | » } |
| 15 | 15 | ||
| Offset 1, 25 lines modified | Offset 1, 25 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·TMPro; | 2 | using·TMPro; |
| 3 | using·UnityEngine; | 3 | using·UnityEngine; |
| 4 | 4 | ||
| 5 | public·static·class·PlayerNameColor | 5 | public·static·class·PlayerNameColor |
| 6 | { | 6 | { |
| 7 | » public·static·Color·Get( | 7 | » public·static·Color·Get(NetworkedPlayerInfo·pc) |
| 8 | » { | 8 | » { |
| 9 | » » return·PlayerNameColor.Get((pc·!=·null)·?·pc.Role·:·null); | 9 | » » return·PlayerNameColor.Get((pc·!=·null)·?·pc.Role·:·null); |
| 10 | » } | 10 | » } |
| 11 | 11 | ||
| 12 | » public·static·void·Set(PlayerControl·pc) | 12 | » public·static·void·Set(PlayerControl·pc) |
| 13 | » { | 13 | » { |
| 14 | » » | 14 | » » NetworkedPlayerInfo·data·=·pc.Data; |
| 15 | » » PlayerNameColor.Set(pc,·(data·!=·null)·?·data.Role·:·null); | 15 | » » PlayerNameColor.Set(pc,·(data·!=·null)·?·data.Role·:·null); |
| 16 | » } | 16 | » } |
| 17 | 17 | ||
| 18 | » public·static·void·Set( | 18 | » public·static·void·Set(NetworkedPlayerInfo·playerInfo,·TextMeshPro·name) |
| 19 | » { | 19 | » { |
| 20 | » » PlayerNameColor.Set(name,·(playerInfo·!=·null)·?·playerInfo.Role·:·null); | 20 | » » PlayerNameColor.Set(name,·(playerInfo·!=·null)·?·playerInfo.Role·:·null); |
| 21 | » } | 21 | » } |
| 22 | 22 | ||
| 23 | » public·static·void·SetForRoleDirectly(PlayerControl·player,·RoleBehaviour·role) | 23 | » public·static·void·SetForRoleDirectly(PlayerControl·player,·RoleBehaviour·role) |
| 24 | » { | 24 | » { |
| 25 | » » if·(!player.AmOwner) | 25 | » » if·(!player.AmOwner) |
| Offset 2, 76 lines modified | Offset 2, 88 lines modified | ||
| 2 | using·System.Collections.Generic; | 2 | using·System.Collections.Generic; |
| 3 | using·AmongUs.GameOptions; | 3 | using·AmongUs.GameOptions; |
| 4 | using·TMPro; | 4 | using·TMPro; |
| 5 | using·UnityEngine; | 5 | using·UnityEngine; |
| 6 | 6 | ||
| 7 | public·class·PlayerOption·:·OptionBehaviour | 7 | public·class·PlayerOption·:·OptionBehaviour |
| 8 | { | 8 | { |
| 9 | » public·override·void·SetUpFromData(BaseGameSetting·data,·int·maskLayer) | ||
| 10 | » { | ||
| 11 | » » base.SetUpFromData(data,·maskLayer); | ||
| 12 | » » PlayerSelectionGameSetting·playerSelectionGameSetting·=·data·as·PlayerSelectionGameSetting; | ||
| 13 | » » if·(playerSelectionGameSetting·==·null) | ||
| 14 | » » { | ||
| 15 | » » » return; | ||
| 16 | » » } | ||
| 17 | » » this.optionName·=·playerSelectionGameSetting.OptionName; | ||
| 18 | » } | ||
| 19 | |||
| 9 | » public·void·OnEnable() | 20 | » public·void·OnEnable() |
| 10 | » { | 21 | » { |
| 11 | » » this.Values·=·new·List< | 22 | » » this.Values·=·new·List<NetworkedPlayerInfo>(GameData.Instance.AllPlayers); |
| 12 | » » this.Values.Sort(( | 23 | » » this.Values.Sort((NetworkedPlayerInfo·a,·NetworkedPlayerInfo·b)·=>·a.PlayerId.CompareTo(b.PlayerId)); |
| 13 | » » this.Value·=·GameOptionsManager.Instance.GameHostOptions.GetInt(Int32OptionNames.ImpostorPlayerID); | 24 | » » this.Value·=·GameOptionsManager.Instance.GameHostOptions.GetInt(Int32OptionNames.ImpostorPlayerID); |
| 14 | » » this.playerIndex·=·this.Values.FindIndex(( | 25 | » » this.playerIndex·=·this.Values.FindIndex((NetworkedPlayerInfo·p)·=>·(int)p.PlayerId·==·this.Value); |
| 15 | » » this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>()); | 26 | » » this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>()); |
| 16 | » » this.OptionUnavailableTxt.color·=·Palette.DisabledGrey; | ||
| 17 | » » this.SetValueText(); | 27 | » » this.SetValueText(); |
| 28 | » » this.AdjustButtonsActiveState(); | ||
| 18 | » } | ||
| 19 | |||
| 20 | » private·void·Awake() | ||
| 21 | » { | ||
| 22 | » » this.PlusBtn·=·this.PlusTxt.gameObject.GetComponent<PassiveButton>(); | ||
| 23 | » » this.MinusBtn·=·this.MinusTxt.gameObject.GetComponent<PassiveButton>(); | ||
| 24 | » } | 29 | » } |
| 25 | 30 | ||
| 26 | » private·void·SetValueText() | 31 | » private·void·SetValueText() |
| 27 | » { | 32 | » { |
| 28 | » » bool·isGamePublic·=·AmongUsClient.Instance.IsGamePublic; | 33 | » » bool·isGamePublic·=·AmongUsClient.Instance.IsGamePublic; |
| 29 | » » this.ValueText.gameObject.SetActive(!isGamePublic); | ||
| 30 | » » if·(this.playerIndex·<·0) | 34 | » » if·(this.playerIndex·<·0) |
| 31 | » » { | 35 | » » { |
| 32 | » » » this.ValueText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoundRobin,·Array.Empty<object>()); | 36 | » » » this.ValueText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoundRobin,·Array.Empty<object>()); |
| 33 | » » } | 37 | » » } |
| 34 | » » else | 38 | » » else |
| 35 | » » { | 39 | » » { |
| 36 | » » » this.ValueText.text·=·this.Values[this.playerIndex].PlayerName; | 40 | » » » this.ValueText.text·=·this.Values[this.playerIndex].PlayerName; |
| 37 | » » } | 41 | » » } |
| 38 | » » this.ValueText.color·=·(isGamePublic·?·Palette.DisabledGrey·:·Color.white); | ||
| 39 | » » this. | 42 | » » this.ValueText.gameObject.SetActive(!isGamePublic); |
| 43 | » » this.ValueBox.gameObject.SetActive(!isGamePublic); | ||
| 40 | » » this.Plus | 44 | » » this.PlusBtn.gameObject.SetActive(!isGamePublic); |
| 41 | » » this.Minus | 45 | » » this.MinusBtn.gameObject.SetActive(!isGamePublic); |
| 42 | » » this.PlusBtn.enabled·=·!isGamePublic; | ||
| 43 | » » this.MinusBtn.enabled·=·!isGamePublic; | ||
| 44 | » » this.OptionUnavailableTxt.gameObject.SetActive(isGamePublic); | 46 | » » this.OptionUnavailableTxt.gameObject.SetActive(isGamePublic); |
| 45 | » } | 47 | » } |
| 46 | 48 | ||
| 47 | » private·void·FixedUpdate() | 49 | » private·void·FixedUpdate() |
| 48 | » { | 50 | » { |
| 49 | » » if·(GameData.Instance.AllPlayers.Count·!=·this.Values.Count) | 51 | » » if·(GameData.Instance.AllPlayers.Count·!=·this.Values.Count) |
| 50 | » » { | 52 | » » { |
| 51 | » » » this.Values·=·new·List< | 53 | » » » this.Values·=·new·List<NetworkedPlayerInfo>(GameData.Instance.AllPlayers); |
| 52 | » » » this.Values.Sort(( | 54 | » » » this.Values.Sort((NetworkedPlayerInfo·a,·NetworkedPlayerInfo·b)·=>·a.PlayerId.CompareTo(b.PlayerId)); |
| 53 | » » » this.playerIndex·=·this.Values.FindIndex(( | 55 | » » » this.playerIndex·=·this.Values.FindIndex((NetworkedPlayerInfo·p)·=>·(int)p.PlayerId·==·this.Value); |
| 54 | » » » this.SetValueText(); | 56 | » » » this.SetValueText(); |
| 55 | » » } | 57 | » » } |
| 56 | » » this.CheckValueChanged(); | 58 | » » this.CheckValueChanged(); |
| 57 | » } | 59 | » } |
| 58 | 60 | ||
| 59 | » public·void·Increase() | 61 | » public·void·Increase() |
| 60 | » { | 62 | » { |
| 63 | » » if·(this.playerIndex·>=·this.Values.Count·-·1) | ||
| 64 | » » { | ||
| 65 | » » » return; | ||
| 66 | » » } | ||
| 61 | » » this.UpdatePlayerIndex(Mathf.Clamp(this.playerIndex·+·1,·-1,·this.Values.Count·-·1)); | 67 | » » this.UpdatePlayerIndex(Mathf.Clamp(this.playerIndex·+·1,·-1,·this.Values.Count·-·1)); |
| 62 | » » this.CheckValueChanged(); | 68 | » » this.CheckValueChanged(); |
| 63 | » » this.OnValueChanged(this); | 69 | » » this.OnValueChanged(this); |
| 70 | » » this.AdjustButtonsActiveState(); | ||
| 64 | » } | 71 | » } |
| 65 | 72 | ||
| 66 | » public·void·Decrease() | 73 | » public·void·Decrease() |
| 67 | » { | 74 | » { |
| 75 | » » if·(this.playerIndex·<·0) | ||
| 76 | » » { | ||
| 77 | » » » return; | ||
| 78 | » » } | ||
| 68 | » » this.UpdatePlayerIndex(Mathf.Clamp(this.playerIndex·-·1,·-1,·this.Values.Count·-·1)); | 79 | » » this.UpdatePlayerIndex(Mathf.Clamp(this.playerIndex·-·1,·-1,·this.Values.Count·-·1)); |
| 69 | » » this.CheckValueChanged(); | 80 | » » this.CheckValueChanged(); |
| 70 | » » this.OnValueChanged(this); | 81 | » » this.OnValueChanged(this); |
| 82 | » » this.AdjustButtonsActiveState(); | ||
| 71 | » } | 83 | » } |
| 72 | 84 | ||
| 73 | » public·override·int·GetInt() | 85 | » public·override·int·GetInt() |
| 74 | » { | 86 | » { |
| 75 | » » if·(AmongUsClient.Instance.IsGamePublic) | 87 | » » if·(AmongUsClient.Instance.IsGamePublic) |
| 76 | » » { | 88 | » » { |
| 77 | » » » return·-1; | 89 | » » » return·-1; |
| Offset 93, 15 lines modified | Offset 105, 44 lines modified | ||
| 93 | 105 | ||
| 94 | » private·void·CheckValueChanged() | 106 | » private·void·CheckValueChanged() |
| 95 | » { | 107 | » { |
| 96 | » » if·(this.oldValue·!=·this.Value) | 108 | » » if·(this.oldValue·!=·this.Value) |
| 97 | » » { | 109 | » » { |
| 98 | » » » this.oldValue·=·this.Value; | 110 | » » » this.oldValue·=·this.Value; |
| 99 | » » » this.SetValueText(); | 111 | » » » this.SetValueText(); |
| 112 | » » » this.UpdateValue(); | ||
| 113 | » » } | ||
| 114 | » } | ||
| 115 | |||
| 116 | » private·void·UpdateValue() | ||
| 117 | » { | ||
| 118 | » » if·(this.optionName·!=·Int32OptionNames.Invalid) | ||
| 119 | » » { | ||
| 120 | » » » GameOptionsManager.Instance.CurrentGameOptions.SetInt(this.optionName,·this.GetInt()); | ||
| 121 | » » » return; | ||
| 122 | » » } | ||
| 123 | » » Debug.LogError("Could·not·update·value·of·"·+·this.Title.ToString()); | ||
| 124 | » } | ||
| 125 | |||
| 126 | » private·void·AdjustButtonsActiveState() | ||
| 127 | » { | ||
| 128 | » » if·(this.Value·<·0) | ||
| 129 | » » { | ||
| 130 | » » » this.MinusBtn.SetInteractable(false); | ||
| 131 | » » » this.PlusBtn.SetInteractable(true); | ||
| Max diff block lines reached; 967/5843 bytes (16.55%) of diff not shown. | |||
| Offset 31, 16 lines modified | Offset 31, 24 lines modified | ||
| 31 | » } | 31 | » } |
| 32 | 32 | ||
| 33 | » public·void·StopPetting() | 33 | » public·void·StopPetting() |
| 34 | » { | 34 | » { |
| 35 | » » base.gameObject.SetActive(false); | 35 | » » base.gameObject.SetActive(false); |
| 36 | » } | 36 | » } |
| 37 | 37 | ||
| 38 | » public·void·SetAlpha(float·alphaValue) | ||
| 39 | » { | ||
| 40 | » » this.HandSprite.color·=·this.HandSprite.color.SetAlpha(alphaValue); | ||
| 41 | » » this.hearts.color·=·this.hearts.color.SetAlpha(alphaValue); | ||
| 42 | » } | ||
| 43 | |||
| 38 | » public·SpriteRenderer·HandSprite; | 44 | » public·SpriteRenderer·HandSprite; |
| 39 | 45 | ||
| 46 | » public·SpriteRenderer·hearts; | ||
| 47 | |||
| 40 | » public·SpriteAnim·HandSpriteAnim; | 48 | » public·SpriteAnim·HandSpriteAnim; |
| 41 | 49 | ||
| 42 | » public·AnimationClip·PetClip; | 50 | » public·AnimationClip·PetClip; |
| 43 | 51 | ||
| 44 | » private·const·int·PET_ANIMATION_START_FRAME·=·6; | 52 | » private·const·int·PET_ANIMATION_START_FRAME·=·6; |
| 45 | 53 | ||
| 46 | » private·const·float·ZPOS_PETTING·=·1E-05f; | 54 | » private·const·float·ZPOS_PETTING·=·1E-05f; |
| Offset 198, 25 lines modified | Offset 198, 29 lines modified | ||
| 198 | » » this.myPlayer.cosmetics.EnsureInitialized(bodyType); | 198 | » » this.myPlayer.cosmetics.EnsureInitialized(bodyType); |
| 199 | » » this.Animations.SetBodyType(bodyType,·this.myPlayer.cosmetics.FlippedCosmeticOffset,·this.myPlayer.cosmetics.NormalCosmeticOffset); | 199 | » » this.Animations.SetBodyType(bodyType,·this.myPlayer.cosmetics.FlippedCosmeticOffset,·this.myPlayer.cosmetics.NormalCosmeticOffset); |
| 200 | » » this.Animations.PlayIdleAnimation(); | 200 | » » this.Animations.PlayIdleAnimation(); |
| 201 | » } | 201 | » } |
| 202 | 202 | ||
| 203 | » private·void·FixedUpdate() | 203 | » private·void·FixedUpdate() |
| 204 | » { | 204 | » { |
| 205 | » » | 205 | » » NetworkedPlayerInfo·data·=·this.myPlayer.Data; |
| 206 | » » bool·flag·=·data·!=·null·&&·data.IsDead; | 206 | » » bool·flag·=·data·!=·null·&&·data.IsDead; |
| 207 | » » this.HandleAnimation(flag); | 207 | » » this.HandleAnimation(flag); |
| 208 | » » if·(base.AmOwner) | 208 | » » if·(base.AmOwner) |
| 209 | » » { | 209 | » » { |
| 210 | » » » if·(this.myPlayer.CanMove·&&·GameData.Instance·&&·DestroyableSingleton<HudManager>.InstanceExists·&&·DestroyableSingleton<HudManager>.Instance.joystick·!=·null) | 210 | » » » if·(this.myPlayer.CanMove·&&·GameData.Instance·&&·DestroyableSingleton<HudManager>.InstanceExists·&&·DestroyableSingleton<HudManager>.Instance.joystick·!=·null) |
| 211 | » » » { | 211 | » » » { |
| 212 | » » » » this.SetNormalizedVelocity(DestroyableSingleton<HudManager>.Instance.joystick.DeltaL); | 212 | » » » » this.SetNormalizedVelocity(DestroyableSingleton<HudManager>.Instance.joystick.DeltaL); |
| 213 | » » » } | 213 | » » » } |
| 214 | » » » this.CheckCancelPetting(); | 214 | » » » this.CheckCancelPetting(); |
| 215 | » » } | 215 | » » } |
| 216 | » » if·(this.myPlayer.PhantomFadeActive) | ||
| 217 | » » { | ||
| 218 | » » » this.myPlayer.cosmetics.SetPhantomRoleAlpha(this.myPlayer.CalculatedAlpha); | ||
| 219 | » » } | ||
| 216 | » } | 220 | » } |
| 217 | 221 | ||
| 218 | » public·Vector2·GetVelocity() | 222 | » public·Vector2·GetVelocity() |
| 219 | » { | 223 | » { |
| 220 | » » return·this.body.velocity; | 224 | » » return·this.body.velocity; |
| 221 | » } | 225 | » } |
| 222 | 226 | ||
| Offset 260, 21 lines modified | Offset 264, 21 lines modified | ||
| 260 | » » » » } | 264 | » » » » } |
| 261 | » » » } | 265 | » » » } |
| 262 | » » }); | 266 | » » }); |
| 263 | » } | 267 | » } |
| 264 | 268 | ||
| 265 | » public·void·StartClimb(bool·down) | 269 | » public·void·StartClimb(bool·down) |
| 266 | » { | 270 | » { |
| 271 | » » this.FlipX·=·false; | ||
| 267 | » » this.Animations.PlayClimbAnimation(down); | 272 | » » this.Animations.PlayClimbAnimation(down); |
| 268 | » » this.myPlayer.cosmetics.AnimateClimb(down); | 273 | » » this.myPlayer.cosmetics.AnimateClimb(down); |
| 269 | » » this.myPlayer.cosmetics.TogglePetVisible(false); | 274 | » » this.myPlayer.cosmetics.TogglePetVisible(false); |
| 270 | » » if·(this.bodyType.GetVisorOptions().HideDuringClimb) | 275 | » » if·(this.bodyType.GetVisorOptions().HideDuringClimb) |
| 271 | » » { | 276 | » » { |
| 272 | » » » this.myPlayer.cosmetics.ToggleVisor(false); | 277 | » » » this.myPlayer.cosmetics.ToggleVisor(false); |
| 273 | » » » this.FlipX·=·false; | ||
| 274 | » » } | 278 | » » } |
| 275 | » } | 279 | » } |
| 276 | 280 | ||
| 277 | » private·void·ClimbLadder(Ladder·source,·byte·climbLadderSid) | 281 | » private·void·ClimbLadder(Ladder·source,·byte·climbLadderSid) |
| 278 | » { | 282 | » { |
| 279 | » » if·(!NetHelpers.SidGreaterThan(climbLadderSid,·this.lastClimbLadderSid)) | 283 | » » if·(!NetHelpers.SidGreaterThan(climbLadderSid,·this.lastClimbLadderSid)) |
| 280 | » » { | 284 | » » { |
| Offset 300, 16 lines modified | Offset 304, 16 lines modified | ||
| 300 | » » this.myPlayer.NetTransform.enabled·=·false; | 304 | » » this.myPlayer.NetTransform.enabled·=·false; |
| 301 | » » this.myPlayer.SetKinematic(true); | 305 | » » this.myPlayer.SetKinematic(true); |
| 302 | » » this.myPlayer.NetTransform.ClearPositionQueues(); | 306 | » » this.myPlayer.NetTransform.ClearPositionQueues(); |
| 303 | » » if·(this.myPlayer.AmOwner) | 307 | » » if·(this.myPlayer.AmOwner) |
| 304 | » » { | 308 | » » { |
| 305 | » » » this.myPlayer.MyPhysics.inputHandler.enabled·=·true; | 309 | » » » this.myPlayer.MyPhysics.inputHandler.enabled·=·true; |
| 306 | » » } | 310 | » » } |
| 307 | » » GameServerUtils.DebugEstimatedWalkTo("walkToSeconds·(estimated)",·base.transform.position,·this.myPlayer.Collider.offset,·source.transform.position,·this.Speed,·0.00 | 311 | » » GameServerUtils.DebugEstimatedWalkTo("walkToSeconds·(estimated)",·base.transform.position,·this.myPlayer.Collider.offset,·source.transform.position,·this.Speed,·0.0005f); |
| 308 | » » yield·return·this.WalkPlayerTo(source.transform.position,·0.00 | 312 | » » yield·return·this.WalkPlayerTo(source.transform.position,·0.0005f,·1f,·false); |
| 309 | » » GameServerUtils.DebugTime("walkToSeconds",·ref·ladderTime,·Time.time); | 313 | » » GameServerUtils.DebugTime("walkToSeconds",·ref·ladderTime,·Time.time); |
| 310 | » » yield·return·Effects.Wait(0.1f); | 314 | » » yield·return·Effects.Wait(0.1f); |
| 311 | » » GameServerUtils.DebugTime("waitSeconds",·ref·ladderTime,·Time.time); | 315 | » » GameServerUtils.DebugTime("waitSeconds",·ref·ladderTime,·Time.time); |
| 312 | » » this.StartClimb(source.IsTop); | 316 | » » this.StartClimb(source.IsTop); |
| 313 | » » if·(Constants.ShouldPlaySfx()·&&·PlayerControl.LocalPlayer·==·this.myPlayer) | 317 | » » if·(Constants.ShouldPlaySfx()·&&·PlayerControl.LocalPlayer·==·this.myPlayer) |
| 314 | » » { | 318 | » » { |
| 315 | » » » this.myPlayer.FootSteps.clip·=·source.UseSound; | 319 | » » » this.myPlayer.FootSteps.clip·=·source.UseSound; |
| Offset 354, 15 lines modified | Offset 358, 15 lines modified | ||
| 354 | » » base.enabled·=·true; | 358 | » » base.enabled·=·true; |
| 355 | » » if·(this.myPlayer) | 359 | » » if·(this.myPlayer) |
| 356 | » » { | 360 | » » { |
| 357 | » » » this.myPlayer.petting·=·false; | 361 | » » » this.myPlayer.petting·=·false; |
| 358 | » » » this.myPlayer.inVent·=·false; | 362 | » » » this.myPlayer.inVent·=·false; |
| 359 | » » » this.myPlayer.isKilling·=·false; | 363 | » » » this.myPlayer.isKilling·=·false; |
| 360 | » » » this.myPlayer.walkingToVent·=·false; | 364 | » » » this.myPlayer.walkingToVent·=·false; |
| 361 | » » » this.myPlayer. | 365 | » » » this.myPlayer.onLadder·=·false; |
| 362 | » » » this.myPlayer.shapeshifting·=·false; | 366 | » » » this.myPlayer.shapeshifting·=·false; |
| 363 | » » » this.myPlayer.waitingForShapeshiftResponse·=·false; | 367 | » » » this.myPlayer.waitingForShapeshiftResponse·=·false; |
| 364 | » » » this.myPlayer.cosmetics.SetScale(this.Animations.DefaultPlayerScale,·this.myPlayer.defaultCosmeticsScale); | 368 | » » » this.myPlayer.cosmetics.SetScale(this.Animations.DefaultPlayerScale,·this.myPlayer.defaultCosmeticsScale); |
| 365 | » » » this.myPlayer.cosmetics.PettingHand.StopPetting(); | 369 | » » » this.myPlayer.cosmetics.PettingHand.StopPetting(); |
| 366 | » » » this.myPlayer.NetTransform.enabled·=·true; | 370 | » » » this.myPlayer.NetTransform.enabled·=·true; |
| 367 | » » » this.myPlayer.NetTransform.SetPaused(false); | 371 | » » » this.myPlayer.NetTransform.SetPaused(false); |
| 368 | » » » this.myPlayer.SetKinematic(false); | 372 | » » » this.myPlayer.SetKinematic(false); |
| Offset 380, 15 lines modified | Offset 384, 15 lines modified | ||
| 380 | » } | 384 | » } |
| 381 | 385 | ||
| 382 | » public·void·ResetAnimState() | 386 | » public·void·ResetAnimState() |
| 383 | » { | 387 | » { |
| 384 | » » this.myPlayer.FootSteps.Stop(); | 388 | » » this.myPlayer.FootSteps.Stop(); |
| 385 | » » this.myPlayer.FootSteps.loop·=·false; | 389 | » » this.myPlayer.FootSteps.loop·=·false; |
| 386 | » » this.myPlayer.cosmetics.SetHatAndVisorIdle(this.myPlayer.CurrentOutfit.ColorId); | 390 | » » this.myPlayer.cosmetics.SetHatAndVisorIdle(this.myPlayer.CurrentOutfit.ColorId); |
| 387 | » » | 391 | » » NetworkedPlayerInfo·data·=·this.myPlayer.Data; |
| 388 | » » if·(data·==·null·||·!data.IsDead) | 392 | » » if·(data·==·null·||·!data.IsDead) |
| 389 | » » { | 393 | » » { |
| 390 | » » » this.myPlayer.cosmetics.AnimateSkinIdle(); | 394 | » » » this.myPlayer.cosmetics.AnimateSkinIdle(); |
| 391 | » » » this.Animations.PlayIdleAnimation(); | 395 | » » » this.Animations.PlayIdleAnimation(); |
| 392 | » » » this.myPlayer.Visible·=·true; | 396 | » » » this.myPlayer.Visible·=·true; |
| 393 | » » » this.myPlayer.SetHatAndVisorAlpha(1f); | 397 | » » » this.myPlayer.SetHatAndVisorAlpha(1f); |
| 394 | » » » return; | 398 | » » » return; |
| Offset 765, 14 lines modified | Offset 769, 16 lines modified | ||
| 765 | » [NonSerialized] | 769 | » [NonSerialized] |
| 766 | » public·SpecialInputHandler·inputHandler; | 770 | » public·SpecialInputHandler·inputHandler; |
| 767 | 771 | ||
| 768 | » public·float·Speed·=·4.5f; | 772 | » public·float·Speed·=·4.5f; |
| 769 | 773 | ||
| 770 | » public·float·GhostSpeed·=·3f; | 774 | » public·float·GhostSpeed·=·3f; |
| 771 | 775 | ||
| 776 | » private·const·float·ClimbPositionTolerance·=·0.0005f; | ||
| 777 | |||
| 772 | » private·readonly·global::Logger·logger·=·new·global::Logger("PlayerPhysics",·global::Logger.Level.Debug,·global::Logger.Category.Gameplay); | 778 | » private·readonly·global::Logger·logger·=·new·global::Logger("PlayerPhysics",·global::Logger.Level.Debug,·global::Logger.Category.Gameplay); |
| 773 | 779 | ||
| 774 | » private·Rigidbody2D·body; | 780 | » private·Rigidbody2D·body; |
| 775 | 781 | ||
| 776 | » private·PlayerControl·myPlayer; | 782 | » private·PlayerControl·myPlayer; |
| 777 | 783 | ||
| 778 | » private·PlayerBodyTypes·bodyType; | 784 | » private·PlayerBodyTypes·bodyType; |
| Offset 5, 15 lines modified | Offset 5, 15 lines modified | ||
| 5 | using·AmongUs.Data.Player; | 5 | using·AmongUs.Data.Player; |
| 6 | using·UnityEngine; | 6 | using·UnityEngine; |
| 7 | 7 | ||
| 8 | public·class·PlayerPurchasesData | 8 | public·class·PlayerPurchasesData |
| 9 | { | 9 | { |
| 10 | » public·PlayerPurchasesData() | 10 | » public·PlayerPurchasesData() |
| 11 | » { | 11 | » { |
| 12 | » » this.purchases·=·new· | 12 | » » this.purchases·=·new·List<string>(); |
| 13 | » } | 13 | » } |
| 14 | 14 | ||
| 15 | » public·void·UpdateLegacyPurchases() | 15 | » public·void·UpdateLegacyPurchases() |
| 16 | » { | 16 | » { |
| 17 | » » foreach·(string·text·in·PlayerStoreData.LEGACY_PURCHASE_KEYS) | 17 | » » foreach·(string·text·in·PlayerStoreData.LEGACY_PURCHASE_KEYS) |
| 18 | » » { | 18 | » » { |
| 19 | » » » this.ClearPurchase(text); | 19 | » » » this.ClearPurchase(text); |
| Offset 60, 20 lines modified | Offset 60, 20 lines modified | ||
| 60 | » public·void·ClearPurchase(string·key) | 60 | » public·void·ClearPurchase(string·key) |
| 61 | » { | 61 | » { |
| 62 | » » this.purchases.Remove(key); | 62 | » » this.purchases.Remove(key); |
| 63 | » } | 63 | » } |
| 64 | 64 | ||
| 65 | » public·void·ClearAllPurchases() | 65 | » public·void·ClearAllPurchases() |
| 66 | » { | 66 | » { |
| 67 | » » | 67 | » » List<string>·list·=·new·List<string>(); |
| 68 | » » foreach·(string·text·in·this.purchases) | 68 | » » foreach·(string·text·in·this.purchases) |
| 69 | » » { | 69 | » » { |
| 70 | » » » if·(Enumerable.Contains<string>(PlayerStoreData.LEGACY_PURCHASE_KEYS,·text)) | 70 | » » » if·(Enumerable.Contains<string>(PlayerStoreData.LEGACY_PURCHASE_KEYS,·text)) |
| 71 | » » » { | 71 | » » » { |
| 72 | » » » » | 72 | » » » » list.Add(text); |
| 73 | » » » } | 73 | » » » } |
| 74 | » » } | 74 | » » } |
| 75 | » » this.purchases·=· | 75 | » » this.purchases·=·list; |
| 76 | » } | 76 | » } |
| 77 | 77 | ||
| 78 | » private· | 78 | » private·List<string>·purchases; |
| 79 | } | 79 | } |
| Offset 102, 19 lines modified | Offset 102, 19 lines modified | ||
| 102 | » { | 102 | » { |
| 103 | » » for·(int·i·=·0;·i·<·Palette.PlayerColors.Length;·i++) | 103 | » » for·(int·i·=·0;·i·<·Palette.PlayerColors.Length;·i++) |
| 104 | » » { | 104 | » » { |
| 105 | » » » this.AvailableColors.Add(i); | 105 | » » » this.AvailableColors.Add(i); |
| 106 | » » } | 106 | » » } |
| 107 | » » if·(GameData.Instance) | 107 | » » if·(GameData.Instance) |
| 108 | » » { | 108 | » » { |
| 109 | » » » List< | 109 | » » » List<NetworkedPlayerInfo>·allPlayers·=·GameData.Instance.AllPlayers; |
| 110 | » » » for·(int·j·=·0;·j·<·allPlayers.Count;·j++) | 110 | » » » for·(int·j·=·0;·j·<·allPlayers.Count;·j++) |
| 111 | » » » { | 111 | » » » { |
| 112 | » » » » | 112 | » » » » NetworkedPlayerInfo·networkedPlayerInfo·=·allPlayers[j]; |
| 113 | » » » » this.AvailableColors.Remove( | 113 | » » » » this.AvailableColors.Remove(networkedPlayerInfo.DefaultOutfit.ColorId); |
| 114 | » » » } | 114 | » » » } |
| 115 | » » } | 115 | » » } |
| 116 | » } | 116 | » } |
| 117 | 117 | ||
| 118 | » private·int·GetCurrentColorId() | 118 | » private·int·GetCurrentColorId() |
| 119 | » { | 119 | » { |
| 120 | » » int·num; | 120 | » » int·num; |
| Offset 233, 15 lines modified | Offset 233, 15 lines modified | ||
| 233 | » » this.VotedFor·=·reader.ReadByte(); | 233 | » » this.VotedFor·=·reader.ReadByte(); |
| 234 | » » this.DidReport·=·reader.ReadBoolean(); | 234 | » » this.DidReport·=·reader.ReadBoolean(); |
| 235 | » » this.Flag.enabled·=·this.DidVote·&&·!this.resultsShowing; | 235 | » » this.Flag.enabled·=·this.DidVote·&&·!this.resultsShowing; |
| 236 | » » this.Overlay.gameObject.SetActive(this.AmDead); | 236 | » » this.Overlay.gameObject.SetActive(this.AmDead); |
| 237 | » » this.Megaphone.enabled·=·this.DidReport; | 237 | » » this.Megaphone.enabled·=·this.DidReport; |
| 238 | » } | 238 | » } |
| 239 | 239 | ||
| 240 | » public·void·SetCosmetics( | 240 | » public·void·SetCosmetics(NetworkedPlayerInfo·playerInfo) |
| 241 | » { | 241 | » { |
| 242 | » » this.Background.sprite·=·ShipStatus.Instance.CosmeticsCache.GetNameplate(playerInfo.DefaultOutfit.NamePlateId).Image; | 242 | » » this.Background.sprite·=·ShipStatus.Instance.CosmeticsCache.GetNameplate(playerInfo.DefaultOutfit.NamePlateId).Image; |
| 243 | » » this.PlayerIcon.UpdateFromEitherPlayerDataOrCache(playerInfo,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ComplexUI,·false,·null); | 243 | » » this.PlayerIcon.UpdateFromEitherPlayerDataOrCache(playerInfo,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ComplexUI,·false,·null); |
| 244 | » » this.PlayerIcon.ToggleName(false); | 244 | » » this.PlayerIcon.ToggleName(false); |
| 245 | » » this.NameText.text·=·playerInfo.PlayerName; | 245 | » » this.NameText.text·=·playerInfo.PlayerName; |
| 246 | » » this.LevelNumberText.text·=·ProgressionManager.FormatVisualLevel(playerInfo.PlayerLevel); | 246 | » » this.LevelNumberText.text·=·ProgressionManager.FormatVisualLevel(playerInfo.PlayerLevel); |
| 247 | » » PlayerMaterial.SetColors((int)DataManager.Player.Customization.Color,·this.ThumbsDown); | 247 | » » PlayerMaterial.SetColors((int)DataManager.Player.Customization.Color,·this.ThumbsDown); |
| Offset 90, 22 lines modified | Offset 90, 32 lines modified | ||
| 90 | » } | 90 | » } |
| 91 | 91 | ||
| 92 | » public·void·SetMaskLayer(int·layer) | 92 | » public·void·SetMaskLayer(int·layer) |
| 93 | » { | 93 | » { |
| 94 | » » this.cosmetics.SetMaskLayer(layer); | 94 | » » this.cosmetics.SetMaskLayer(layer); |
| 95 | » } | 95 | » } |
| 96 | 96 | ||
| 97 | » public·void·SetHat | 97 | » public·void·SetHatLeftFacingVictim(bool·leftFacingVictim) |
| 98 | » { | 98 | » { |
| 99 | » » this.cosmetics.SetHatLeftFacingVictim(leftFacingVictim); | ||
| 100 | » } | ||
| 101 | |||
| 102 | » public·void·SetHatOnFloor() | ||
| 103 | » { | ||
| 104 | » » this.cosmetics.SetHatOnFloor(); | ||
| 105 | » } | ||
| 106 | |||
| 107 | » public·void·SetVisorOnFloor() | ||
| 108 | » { | ||
| 99 | » » this.cosmetics.Set | 109 | » » this.cosmetics.SetVisorOnFloor(); |
| 100 | » } | 110 | » } |
| 101 | 111 | ||
| 102 | » public·void·FlipHatAndVisor() | 112 | » public·void·FlipHatAndVisor() |
| 103 | » { | 113 | » { |
| 104 | » » this.cosmetics.SetHat | 114 | » » this.cosmetics.SetHatOnFloor(); |
| 105 | » } | 115 | » } |
| 106 | 116 | ||
| 107 | » public·void·SetHatAndVisorMaskType(PlayerMaterial.MaskType·type) | 117 | » public·void·SetHatAndVisorMaskType(PlayerMaterial.MaskType·type) |
| 108 | » { | 118 | » { |
| 109 | » » this.cosmetics.SetHatAndVisorMaskType(type); | 119 | » » this.cosmetics.SetHatAndVisorMaskType(type); |
| 110 | » } | 120 | » } |
| 111 | 121 | ||
| Offset 266, 26 lines modified | Offset 276, 26 lines modified | ||
| 266 | » » { | 276 | » » { |
| 267 | » » » DataManager.Player.Customization.Visor·=·"visor_EmptyVisor"; | 277 | » » » DataManager.Player.Customization.Visor·=·"visor_EmptyVisor"; |
| 268 | » » } | 278 | » » } |
| 269 | » » this.cosmetics.SetVisor(DataManager.Player.Customization.Visor,·(int)DataManager.Player.Customization.Color); | 279 | » » this.cosmetics.SetVisor(DataManager.Player.Customization.Visor,·(int)DataManager.Player.Customization.Color); |
| 270 | » » this.SetColorBlindTag(); | 280 | » » this.SetColorBlindTag(); |
| 271 | » } | 281 | » } |
| 272 | 282 | ||
| 273 | » public·void·UpdateFromEitherPlayerDataOrCache( | 283 | » public·void·UpdateFromEitherPlayerDataOrCache(NetworkedPlayerInfo·pData,·PlayerOutfitType·outfitType,·PlayerMaterial.MaskType·maskType,·bool·includePet,·Action·OnSkinLoaded·=·null) |
| 274 | » { | 284 | » { |
| 275 | » » this.UpdateFromPlayerData(pData,·outfitType,·maskType,·includePet,·OnSkinLoaded,·false); | 285 | » » this.UpdateFromPlayerData(pData,·outfitType,·maskType,·includePet,·OnSkinLoaded,·false); |
| 276 | » } | 286 | » } |
| 277 | 287 | ||
| 278 | » public·void·UpdateFromPlayerData( | 288 | » public·void·UpdateFromPlayerData(NetworkedPlayerInfo·pData,·PlayerOutfitType·outfitType,·PlayerMaterial.MaskType·maskType,·bool·includePet,·Action·OnSkinLoaded·=·null,·bool·forceAlive·=·false) |
| 279 | » { | 289 | » { |
| 280 | » » | 290 | » » NetworkedPlayerInfo.PlayerOutfit·playerOutfit·=·pData.Outfits[outfitType]; |
| 281 | » » this.UpdateFromPlayerOutfit(playerOutfit,·maskType,·pData.IsDead,·includePet,·OnSkinLoaded,·forceAlive); | 291 | » » this.UpdateFromPlayerOutfit(playerOutfit,·maskType,·pData.IsDead,·includePet,·OnSkinLoaded,·forceAlive); |
| 282 | » } | 292 | » } |
| 283 | 293 | ||
| 284 | » public·void·UpdateFromPlayerOutfit( | 294 | » public·void·UpdateFromPlayerOutfit(NetworkedPlayerInfo.PlayerOutfit·outfit,·PlayerMaterial.MaskType·maskType,·bool·isDead,·bool·includePet,·Action·OnSkinLoaded·=·null,·bool·forceAlive·=·false) |
| 285 | » { | 295 | » { |
| 286 | » » this.cosmetics.SetMaskType(maskType); | 296 | » » this.cosmetics.SetMaskType(maskType); |
| 287 | » » this.cosmetics.SetBodyColor(outfit.ColorId); | 297 | » » this.cosmetics.SetBodyColor(outfit.ColorId); |
| 288 | » » this.Hands.ForEach(delegate(SpriteRenderer·b) | 298 | » » this.Hands.ForEach(delegate(SpriteRenderer·b) |
| 289 | » » { | 299 | » » { |
| 290 | » » » b.sharedMaterial·=·CosmeticsLayer.GetBodyMaterial(maskType); | 300 | » » » b.sharedMaterial·=·CosmeticsLayer.GetBodyMaterial(maskType); |
| 291 | » » » PlayerMaterial.SetColors(outfit.ColorId,·b); | 301 | » » » PlayerMaterial.SetColors(outfit.ColorId,·b); |
| Offset 351, 14 lines modified | Offset 361, 19 lines modified | ||
| 351 | » } | 361 | » } |
| 352 | 362 | ||
| 353 | » public·void·FadeBlackAll(float·duration) | 363 | » public·void·FadeBlackAll(float·duration) |
| 354 | » { | 364 | » { |
| 355 | » » this.cosmetics.FadeBlackCosmetics(duration); | 365 | » » this.cosmetics.FadeBlackCosmetics(duration); |
| 356 | » } | 366 | » } |
| 357 | 367 | ||
| 368 | » public·SkinViewData·GetSkinView() | ||
| 369 | » { | ||
| 370 | » » return·this.cosmetics.GetSkinView(); | ||
| 371 | » } | ||
| 372 | |||
| 358 | » public·SpriteRenderer[]·Hands; | 373 | » public·SpriteRenderer[]·Hands; |
| 359 | 374 | ||
| 360 | » public·SpriteRenderer[]·OtherBodySprites; | 375 | » public·SpriteRenderer[]·OtherBodySprites; |
| 361 | 376 | ||
| 362 | » [SerializeField] | 377 | » [SerializeField] |
| 363 | » private·CosmeticsLayer·cosmetics; | 378 | » private·CosmeticsLayer·cosmetics; |
| 364 | 379 | ||
| Offset 143, 72 lines modified | Offset 143, 72 lines modified | ||
| 143 | » » » this.m_ang7·=·0f; | 143 | » » » this.m_ang7·=·0f; |
| 144 | » » » this.m_ang8·=·0f; | 144 | » » » this.m_ang8·=·0f; |
| 145 | » » » this.m_ang9·=·0f; | 145 | » » » this.m_ang9·=·0f; |
| 146 | » » } | 146 | » » } |
| 147 | 147 | ||
| 148 | » » public·static·readonly·int·NUM_NODES·=·10; | 148 | » » public·static·readonly·int·NUM_NODES·=·10; |
| 149 | 149 | ||
| 150 | » » [HideInInspector] | ||
| 151 | » » [SerializeField] | 150 | » » [SerializeField] |
| 151 | » » [HideInInspector] | ||
| 152 | » » private·Vector2·m_node0·=·Vector2.zero; | 152 | » » private·Vector2·m_node0·=·Vector2.zero; |
| 153 | 153 | ||
| 154 | » » [HideInInspector] | ||
| 155 | » » [SerializeField] | 154 | » » [SerializeField] |
| 155 | » » [HideInInspector] | ||
| 156 | » » private·Vector2·m_node1·=·Vector2.zero; | 156 | » » private·Vector2·m_node1·=·Vector2.zero; |
| 157 | 157 | ||
| 158 | » » [HideInInspector] | 158 | » » [HideInInspector] |
| 159 | » » [SerializeField] | 159 | » » [SerializeField] |
| 160 | » » private·Vector2·m_node2·=·Vector2.zero; | 160 | » » private·Vector2·m_node2·=·Vector2.zero; |
| 161 | 161 | ||
| 162 | » » [SerializeField] | 162 | » » [SerializeField] |
| 163 | » » [HideInInspector] | 163 | » » [HideInInspector] |
| 164 | » » private·Vector2·m_node3·=·Vector2.zero; | 164 | » » private·Vector2·m_node3·=·Vector2.zero; |
| 165 | 165 | ||
| 166 | » » [SerializeField] | 166 | » » [SerializeField] |
| 167 | » » [HideInInspector] | 167 | » » [HideInInspector] |
| 168 | » » private·Vector2·m_node4·=·Vector2.zero; | 168 | » » private·Vector2·m_node4·=·Vector2.zero; |
| 169 | 169 | ||
| 170 | » » [HideInInspector] | ||
| 171 | » » [SerializeField] | 170 | » » [SerializeField] |
| 171 | » » [HideInInspector] | ||
| 172 | » » private·Vector2·m_node5·=·Vector2.zero; | 172 | » » private·Vector2·m_node5·=·Vector2.zero; |
| 173 | 173 | ||
| 174 | » » [HideInInspector] | ||
| 175 | » » [SerializeField] | 174 | » » [SerializeField] |
| 175 | » » [HideInInspector] | ||
| 176 | » » private·Vector2·m_node6·=·Vector2.zero; | 176 | » » private·Vector2·m_node6·=·Vector2.zero; |
| 177 | 177 | ||
| 178 | » » [HideInInspector] | 178 | » » [HideInInspector] |
| 179 | » » [SerializeField] | 179 | » » [SerializeField] |
| 180 | » » private·Vector2·m_node7·=·Vector2.zero; | 180 | » » private·Vector2·m_node7·=·Vector2.zero; |
| 181 | 181 | ||
| 182 | » » [SerializeField] | ||
| 183 | » » [HideInInspector] | 182 | » » [HideInInspector] |
| 183 | » » [SerializeField] | ||
| 184 | » » private·Vector2·m_node8·=·Vector2.zero; | 184 | » » private·Vector2·m_node8·=·Vector2.zero; |
| 185 | 185 | ||
| 186 | » » [SerializeField] | 186 | » » [SerializeField] |
| 187 | » » [HideInInspector] | 187 | » » [HideInInspector] |
| 188 | » » private·Vector2·m_node9·=·Vector2.zero; | 188 | » » private·Vector2·m_node9·=·Vector2.zero; |
| 189 | 189 | ||
| 190 | » » [SerializeField] | ||
| 191 | » » [HideInInspector] | 190 | » » [HideInInspector] |
| 191 | » » [SerializeField] | ||
| 192 | » » private·float·m_ang0; | 192 | » » private·float·m_ang0; |
| 193 | 193 | ||
| 194 | » » [SerializeField] | ||
| 195 | » » [HideInInspector] | 194 | » » [HideInInspector] |
| 195 | » » [SerializeField] | ||
| 196 | » » private·float·m_ang1; | 196 | » » private·float·m_ang1; |
| 197 | 197 | ||
| 198 | » » [SerializeField] | ||
| 199 | » » [HideInInspector] | 198 | » » [HideInInspector] |
| 199 | » » [SerializeField] | ||
| 200 | » » private·float·m_ang2; | 200 | » » private·float·m_ang2; |
| 201 | 201 | ||
| 202 | » » [HideInInspector] | ||
| 203 | » » [SerializeField] | 202 | » » [SerializeField] |
| 203 | » » [HideInInspector] | ||
| 204 | » » private·float·m_ang3; | 204 | » » private·float·m_ang3; |
| 205 | 205 | ||
| 206 | » » [HideInInspector] | ||
| 207 | » » [SerializeField] | 206 | » » [SerializeField] |
| 207 | » » [HideInInspector] | ||
| 208 | » » private·float·m_ang4; | 208 | » » private·float·m_ang4; |
| 209 | 209 | ||
| 210 | » » [SerializeField] | 210 | » » [SerializeField] |
| 211 | » » [HideInInspector] | 211 | » » [HideInInspector] |
| 212 | » » private·float·m_ang5; | 212 | » » private·float·m_ang5; |
| 213 | 213 | ||
| 214 | » » [SerializeField] | 214 | » » [SerializeField] |
| Offset 219, 14 lines modified | Offset 219, 14 lines modified | ||
| 219 | » » [HideInInspector] | 219 | » » [HideInInspector] |
| 220 | » » private·float·m_ang7; | 220 | » » private·float·m_ang7; |
| 221 | 221 | ||
| 222 | » » [HideInInspector] | 222 | » » [HideInInspector] |
| 223 | » » [SerializeField] | 223 | » » [SerializeField] |
| 224 | » » private·float·m_ang8; | 224 | » » private·float·m_ang8; |
| 225 | 225 | ||
| 226 | » » [SerializeField] | ||
| 227 | » » [HideInInspector] | 226 | » » [HideInInspector] |
| 227 | » » [SerializeField] | ||
| 228 | » » private·float·m_ang9; | 228 | » » private·float·m_ang9; |
| 229 | 229 | ||
| 230 | » » private·SpriteRenderer·m_spriteRenderer; | 230 | » » private·SpriteRenderer·m_spriteRenderer; |
| 231 | » } | 231 | » } |
| 232 | } | 232 | } |
| Offset 5, 70 lines modified | Offset 5, 69 lines modified | ||
| 5 | using·UnityEngine; | 5 | using·UnityEngine; |
| 6 | 6 | ||
| 7 | public·class·ProgressionScreen·:·MonoBehaviour | 7 | public·class·ProgressionScreen·:·MonoBehaviour |
| 8 | { | 8 | { |
| 9 | » public·void·Activate() | 9 | » public·void·Activate() |
| 10 | » { | 10 | » { |
| 11 | » » base.gameObject.SetActive(true); | 11 | » » base.gameObject.SetActive(true); |
| 12 | » » ProgressionManager.XpGrantResult· | 12 | » » ProgressionManager.XpGrantResult·cachedXpGrantResult·=·EndGameResult.CachedXpGrantResult; |
| 13 | » » uint·oldLevel·=· | 13 | » » uint·oldLevel·=·cachedXpGrantResult.OldLevel; |
| 14 | » » uint·newLevel·=· | 14 | » » uint·newLevel·=·cachedXpGrantResult.NewLevel; |
| 15 | » » this.XpBar.Value·=· | 15 | » » this.XpBar.Value·=·cachedXpGrantResult.OldXpAmount; |
| 16 | » » this.XpBar.CapValue·=· | 16 | » » this.XpBar.CapValue·=·cachedXpGrantResult.OldXpAmount; |
| 17 | » » this.XpBar.MaxValue·=· | 17 | » » this.XpBar.MaxValue·=·cachedXpGrantResult.XpRequiredToLevelUp; |
| 18 | » » this.XpBar.GlowAlpha·=·0f; | 18 | » » this.XpBar.GlowAlpha·=·0f; |
| 19 | » » this.XpEarnedNowText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.XpGainedValue,·new·object[]·{· | 19 | » » this.XpEarnedNowText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.XpGainedValue,·new·object[]·{·cachedXpGrantResult.GrantedXp·}); |
| 20 | » » this.XpEarnedNowText.color·=·Palette.ClearWhite; | 20 | » » this.XpEarnedNowText.color·=·Palette.ClearWhite; |
| 21 | » » if·(oldLevel·==· | 21 | » » if·(oldLevel·==·cachedXpGrantResult.MaxLevel) |
| 22 | » » { | 22 | » » { |
| 23 | » » » this.XpBar.Value·=·1f; | 23 | » » » this.XpBar.Value·=·1f; |
| 24 | » » » this.XpBar.CapValue·=·1f; | 24 | » » » this.XpBar.CapValue·=·1f; |
| 25 | » » » this.XpBar.MaxValue·=·1f; | 25 | » » » this.XpBar.MaxValue·=·1f; |
| 26 | » » » this.LevelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Max,·Array.Empty<object>()); | 26 | » » » this.LevelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Max,·Array.Empty<object>()); |
| 27 | » » » this.FutureLevelText.color·=·Palette.ClearWhite; | 27 | » » » this.FutureLevelText.color·=·Palette.ClearWhite; |
| 28 | » » } | 28 | » » } |
| 29 | » » else·if·(newLevel·==· | 29 | » » else·if·(newLevel·==·cachedXpGrantResult.MaxLevel) |
| 30 | » » { | 30 | » » { |
| 31 | » » » this.FutureLevelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Max,·Array.Empty<object>()); | 31 | » » » this.FutureLevelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Max,·Array.Empty<object>()); |
| 32 | » » » this.LevelText.text·=·ProgressionManager.FormatVisualLevel(oldLevel); | 32 | » » » this.LevelText.text·=·ProgressionManager.FormatVisualLevel(oldLevel); |
| 33 | » » } | 33 | » » } |
| 34 | » » else | 34 | » » else |
| 35 | » » { | 35 | » » { |
| 36 | » » » this.LevelText.text·=·ProgressionManager.FormatVisualLevel(oldLevel); | 36 | » » » this.LevelText.text·=·ProgressionManager.FormatVisualLevel(oldLevel); |
| 37 | » » » string·text·=·ProgressionManager.FormatVisualLevel((newLevel·==·oldLevel)·?·(oldLevel·+·1U)·:·newLevel); | 37 | » » » string·text·=·ProgressionManager.FormatVisualLevel((newLevel·==·oldLevel)·?·(oldLevel·+·1U)·:·newLevel); |
| 38 | » » » this.FutureLevelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LevelShorthand,·new·object[]·{·text·}); | 38 | » » » this.FutureLevelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LevelShorthand,·new·object[]·{·text·}); |
| 39 | » » } | 39 | » » } |
| 40 | » » ProgressionManager.CurrencyGrantResult· | 40 | » » ProgressionManager.CurrencyGrantResult·cachedPodsGrantResult·=·EndGameResult.CachedPodsGrantResult; |
| 41 | » » CosmicubeData·dataForPodId·=·DestroyableSingleton<CosmicubeManager>.Instance.GetDataForPodId( | 41 | » » CosmicubeData·dataForPodId·=·DestroyableSingleton<CosmicubeManager>.Instance.GetDataForPodId(cachedPodsGrantResult.PodId); |
| 42 | » » if·(!(dataForPodId·==·null)·&&·!(dataForPodId.GetCosmicubeName()·==·"Empty·Cosmicube")·&&· | 42 | » » if·(!(dataForPodId·==·null)·&&·!(dataForPodId.GetCosmicubeName()·==·"Empty·Cosmicube")·&&·cachedPodsGrantResult.GrantedPodsWithMultiplierApplied·>·0U) |
| 43 | » » { | 43 | » » { |
| 44 | » » » this.PodsEarned.Initialize( | 44 | » » » this.PodsEarned.Initialize(cachedPodsGrantResult); |
| 45 | » » } | 45 | » » } |
| 46 | » » else | 46 | » » else |
| 47 | » » { | 47 | » » { |
| 48 | » » » this.PodsEarned.gameObject.SetActive(false); | 48 | » » » this.PodsEarned.gameObject.SetActive(false); |
| 49 | » » } | 49 | » » } |
| 50 | » » ProgressionManager.CurrencyGrantResult· | 50 | » » ProgressionManager.CurrencyGrantResult·cachedBeansGrantResult·=·EndGameResult.CachedBeansGrantResult; |
| 51 | » » if·( | 51 | » » if·(cachedBeansGrantResult.GrantedPodsWithMultiplierApplied·>·0U) |
| 52 | » » { | 52 | » » { |
| 53 | » » » this.BeansEarned.Initialize( | 53 | » » » this.BeansEarned.Initialize(cachedBeansGrantResult); |
| 54 | » » } | 54 | » » } |
| 55 | » » else | 55 | » » else |
| 56 | » » { | 56 | » » { |
| 57 | » » » this.BeansEarned.gameObject.SetActive(false); | 57 | » » » this.BeansEarned.gameObject.SetActive(false); |
| 58 | » » } | 58 | » » } |
| 59 | » » if·(this.BeansEarned.gameObject.activeSelf·!=·this.PodsEarned.gameObject.activeSelf) | 59 | » » if·(this.BeansEarned.gameObject.activeSelf·!=·this.PodsEarned.gameObject.activeSelf) |
| 60 | » » { | 60 | » » { |
| 61 | » » » Transform·transform·=·(this.BeansEarned.gameObject.activeSelf·?·this.BeansEarned.transform·:·this.PodsEarned.transform); | 61 | » » » Transform·transform·=·(this.BeansEarned.gameObject.activeSelf·?·this.BeansEarned.transform·:·this.PodsEarned.transform); |
| 62 | » » » transform.localPosition·=·new·Vector3(0f,·transform.localPosition.y,·base.transform.localPosition.z); | 62 | » » » transform.localPosition·=·new·Vector3(0f,·transform.localPosition.y,·base.transform.localPosition.z); |
| 63 | » » } | 63 | » » } |
| 64 | » » this.Player.UpdateFromPlayerOutfit(EndGameResult.CachedLocalPlayer.Outfit,·PlayerMaterial.MaskType.None,·false,·true,·null,·false); | ||
| 64 | » » GameData.PlayerInfo·data·=·PlayerControl.LocalPlayer.Data; | ||
| 65 | » » this.Player.UpdateFromEitherPlayerDataOrCache(data,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.None,·true,·null); | ||
| 66 | » » this.Player.ToggleName(false); | 65 | » » this.Player.ToggleName(false); |
| 67 | » » base.StartCoroutine(this.DoAnimations( | 66 | » » base.StartCoroutine(this.DoAnimations(cachedXpGrantResult)); |
| 68 | » } | 67 | » } |
| 69 | 68 | ||
| 70 | » private·IEnumerator·DoAnimations(ProgressionManager.XpGrantResult·xpGainedResult) | 69 | » private·IEnumerator·DoAnimations(ProgressionManager.XpGrantResult·xpGainedResult) |
| 71 | » { | 70 | » { |
| 72 | » » yield·return·Effects.Wait(0.2f); | 71 | » » yield·return·Effects.Wait(0.2f); |
| 73 | » » if·((xpGainedResult.MaxLevel·!=·DataManager.Player.Stats.Level·||·xpGainedResult.OldLevel·!=·xpGainedResult.NewLevel)·&&·xpGainedResult.GrantedXp·>·0U) | 72 | » » if·((xpGainedResult.MaxLevel·!=·DataManager.Player.Stats.Level·||·xpGainedResult.OldLevel·!=·xpGainedResult.NewLevel)·&&·xpGainedResult.GrantedXp·>·0U) |
| 74 | » » { | 73 | » » { |
| Offset 186, 25 lines modified | Offset 185, 25 lines modified | ||
| 186 | » » } | 185 | » » } |
| 187 | » » if·(this.PodsEarned.gameObject.activeSelf) | 186 | » » if·(this.PodsEarned.gameObject.activeSelf) |
| 188 | » » { | 187 | » » { |
| 189 | » » » yield·return·this.PodsEarned.ShowAmount(); | 188 | » » » yield·return·this.PodsEarned.ShowAmount(); |
| 190 | » » } | 189 | » » } |
| 191 | » » if·(this.BeansEarned.gameObject.activeSelf) | 190 | » » if·(this.BeansEarned.gameObject.activeSelf) |
| 192 | » » { | 191 | » » { |
| 193 | » » » ProgressionManager.CurrencyGrantResult· | 192 | » » » ProgressionManager.CurrencyGrantResult·cachedBeansGrantResult·=·EndGameResult.CachedBeansGrantResult; |
| 194 | » » » if·( | 193 | » » » if·(cachedBeansGrantResult.GrantedPodsWithMultiplierApplied·!=·cachedBeansGrantResult.GrantedPodsPreMultiplier) |
| 195 | » » » { | 194 | » » » { |
| 196 | » » » » yield·return·this.BeansEarned.ShowMultiplier(); | 195 | » » » » yield·return·this.BeansEarned.ShowMultiplier(); |
| 197 | » » » } | 196 | » » » } |
| 198 | » » » base.StartCoroutine(this.BeansEarned.EnterWallet()); | 197 | » » » base.StartCoroutine(this.BeansEarned.EnterWallet()); |
| 199 | » » } | 198 | » » } |
| 200 | » » if·(this.PodsEarned.gameObject.activeSelf) | 199 | » » if·(this.PodsEarned.gameObject.activeSelf) |
| 201 | » » { | 200 | » » { |
| 202 | » » » ProgressionManager.CurrencyGrantResult· | 201 | » » » ProgressionManager.CurrencyGrantResult·cachedPodsGrantResult·=·EndGameResult.CachedPodsGrantResult; |
| 203 | » » » if·( | 202 | » » » if·(cachedPodsGrantResult.GrantedPodsWithMultiplierApplied·!=·cachedPodsGrantResult.GrantedPodsPreMultiplier) |
| 204 | » » » { | 203 | » » » { |
| 205 | » » » » yield·return·this.PodsEarned.ShowMultiplier(); | 204 | » » » » yield·return·this.PodsEarned.ShowMultiplier(); |
| 206 | » » » } | 205 | » » » } |
| 207 | » » » base.StartCoroutine(this.PodsEarned.EnterWallet()); | 206 | » » » base.StartCoroutine(this.PodsEarned.EnterWallet()); |
| 208 | » » } | 207 | » » } |
| 209 | » » yield·break; | 208 | » » yield·break; |
| 210 | » } | 209 | » } |
| Offset 25, 15 lines modified | Offset 25, 15 lines modified | ||
| 25 | » » { | 25 | » » { |
| 26 | » » » this.TileParent.enabled·=·true; | 26 | » » » this.TileParent.enabled·=·true; |
| 27 | » » } | 27 | » » } |
| 28 | » » GameData·instance·=·GameData.Instance; | 28 | » » GameData·instance·=·GameData.Instance; |
| 29 | » » if·(instance·&&·instance.TotalTasks·>·0) | 29 | » » if·(instance·&&·instance.TotalTasks·>·0) |
| 30 | » » { | 30 | » » { |
| 31 | » » » int·num·=·(DestroyableSingleton<TutorialManager>.InstanceExists·?·1·:·(instance.AllPlayers.Count·-·GameManager.Instance.LogicOptions.NumImpostors)); | 31 | » » » int·num·=·(DestroyableSingleton<TutorialManager>.InstanceExists·?·1·:·(instance.AllPlayers.Count·-·GameManager.Instance.LogicOptions.NumImpostors)); |
| 32 | » » » num·-=·Enumerable.Count< | 32 | » » » num·-=·Enumerable.Count<NetworkedPlayerInfo>(instance.AllPlayers,·(NetworkedPlayerInfo·p)·=>·p.Disconnected); |
| 33 | » » » switch·(GameManager.Instance.LogicOptions.GetTaskBarMode()) | 33 | » » » switch·(GameManager.Instance.LogicOptions.GetTaskBarMode()) |
| 34 | » » » { | 34 | » » » { |
| 35 | » » » case·TaskBarMode.Normal: | 35 | » » » case·TaskBarMode.Normal: |
| 36 | » » » » break; | 36 | » » » » break; |
| 37 | » » » case·TaskBarMode.MeetingOnly: | 37 | » » » case·TaskBarMode.MeetingOnly: |
| 38 | » » » » if·(!MeetingHud.Instance) | 38 | » » » » if·(!MeetingHud.Instance) |
| 39 | » » » » { | 39 | » » » » { |
| Offset 1, 8 lines modified | Offset 1, 9 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·AmongUs.Data; | ||
| 2 | using·Assets.InnerNet; | 3 | using·Assets.InnerNet; |
| 3 | using·Innersloth.Assets; | 4 | using·Innersloth.Assets; |
| 4 | using·TMPro; | 5 | using·TMPro; |
| 5 | using·UnityEngine; | 6 | using·UnityEngine; |
| 6 | 7 | ||
| 7 | public·class·PurchaseButton·:·MonoBehaviour | 8 | public·class·PurchaseButton·:·MonoBehaviour |
| 8 | { | 9 | { |
| Offset 141, 15 lines modified | Offset 142, 15 lines modified | ||
| 141 | » » » this.SetSquare(); | 142 | » » » this.SetSquare(); |
| 142 | » » » return; | 143 | » » » return; |
| 143 | » » } | 144 | » » } |
| 144 | » » if·(this.Product·is·PetData) | 145 | » » if·(this.Product·is·PetData) |
| 145 | » » { | 146 | » » { |
| 146 | » » » PetData·petData·=·(PetData)this.Product; | 147 | » » » PetData·petData·=·(PetData)this.Product; |
| 147 | » » » this.CrewHeadImage.enabled·=·false; | 148 | » » » this.CrewHeadImage.enabled·=·false; |
| 148 | » » » this.HatImage.FrontLayer | 149 | » » » petData.SetPreview(this.HatImage.FrontLayer,·(int)DataManager.Player.Customization.Color); |
| 149 | » » » this.HatImage.FrontLayer.transform.localPosition·=·new·Vector3(0f,·0.35f,·-0.01f); | 150 | » » » this.HatImage.FrontLayer.transform.localPosition·=·new·Vector3(0f,·0.35f,·-0.01f); |
| 150 | » » » this.HatImage.FrontLayer.transform.localScale·=·Vector3.one·*·0.5f; | 151 | » » » this.HatImage.FrontLayer.transform.localScale·=·Vector3.one·*·0.5f; |
| 151 | » » » this.NameText.text·=·petData.GetItemName(); | 152 | » » » this.NameText.text·=·petData.GetItemName(); |
| 152 | » » » this.SetSquare(); | 153 | » » » this.SetSquare(); |
| 153 | » » » return; | 154 | » » » return; |
| 154 | » » } | 155 | » » } |
| 155 | » » if·(this.Product·is·CosmicubeData) | 156 | » » if·(this.Product·is·CosmicubeData) |
| Offset 1, 15 lines modified | Offset 1, 15 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections.Generic; | 2 | using·System.Collections.Generic; |
| 3 | using·Rewired; | 3 | using·Rewired; |
| 4 | using·TMPro; | 4 | using·TMPro; |
| 5 | using·UnityEngine; | 5 | using·UnityEngine; |
| 6 | 6 | ||
| 7 | [RequireComponent(typeof(MeshRenderer))] | ||
| 8 | [RequireComponent(typeof(MeshFilter))] | 7 | [RequireComponent(typeof(MeshFilter))] |
| 8 | [RequireComponent(typeof(MeshRenderer))] | ||
| 9 | public·class·RadialMenu·:·MonoBehaviour | 9 | public·class·RadialMenu·:·MonoBehaviour |
| 10 | { | 10 | { |
| 11 | » private·void·OnEnable() | 11 | » private·void·OnEnable() |
| 12 | » { | 12 | » { |
| 13 | » » this.mf·=·base.GetComponent<MeshFilter>(); | 13 | » » this.mf·=·base.GetComponent<MeshFilter>(); |
| 14 | » » this.mr·=·base.GetComponent<MeshRenderer>(); | 14 | » » this.mr·=·base.GetComponent<MeshRenderer>(); |
| 15 | » » this.mbp·=·new·MaterialPropertyBlock(); | 15 | » » this.mbp·=·new·MaterialPropertyBlock(); |
| Offset 1238, 32 lines modified | Offset 1238, 32 lines modified | ||
| 1238 | 1238 | ||
| 1239 | » » private·const·int·controllerMapPPKeyVersion·=·2; | 1239 | » » private·const·int·controllerMapPPKeyVersion·=·2; |
| 1240 | 1240 | ||
| 1241 | » » [SerializeField] | 1241 | » » [SerializeField] |
| 1242 | » » [Tooltip("Should·this·script·be·used?·If·disabled,·nothing·will·be·saved·or·loaded.")] | 1242 | » » [Tooltip("Should·this·script·be·used?·If·disabled,·nothing·will·be·saved·or·loaded.")] |
| 1243 | » » private·bool·isEnabled·=·true; | 1243 | » » private·bool·isEnabled·=·true; |
| 1244 | 1244 | ||
| 1245 | » » [SerializeField] | ||
| 1246 | » » [Tooltip("Should·saved·data·be·loaded·on·start?")] | 1245 | » » [Tooltip("Should·saved·data·be·loaded·on·start?")] |
| 1246 | » » [SerializeField] | ||
| 1247 | » » private·bool·loadDataOnStart·=·true; | 1247 | » » private·bool·loadDataOnStart·=·true; |
| 1248 | 1248 | ||
| 1249 | » » [SerializeField] | 1249 | » » [SerializeField] |
| 1250 | » » [Tooltip("Should·Player·Joystick·assignments·be·saved·and·loaded?·This·is·not·totally·reliable·for·all·Joysticks·on·all·platforms.·Some·platforms/input·sources·do·not·provide·enough·information·to·reliably·save·assignments·from·session·to·session·and·reboot·to·reboot.")] | 1250 | » » [Tooltip("Should·Player·Joystick·assignments·be·saved·and·loaded?·This·is·not·totally·reliable·for·all·Joysticks·on·all·platforms.·Some·platforms/input·sources·do·not·provide·enough·information·to·reliably·save·assignments·from·session·to·session·and·reboot·to·reboot.")] |
| 1251 | » » private·bool·loadJoystickAssignments·=·true; | 1251 | » » private·bool·loadJoystickAssignments·=·true; |
| 1252 | 1252 | ||
| 1253 | » » [SerializeField] | ||
| 1254 | » » [Tooltip("Should·Player·Keyboard·assignments·be·saved·and·loaded?")] | 1253 | » » [Tooltip("Should·Player·Keyboard·assignments·be·saved·and·loaded?")] |
| 1254 | » » [SerializeField] | ||
| 1255 | » » private·bool·loadKeyboardAssignments·=·true; | 1255 | » » private·bool·loadKeyboardAssignments·=·true; |
| 1256 | 1256 | ||
| 1257 | » » [Tooltip("Should·Player·Mouse·assignments·be·saved·and·loaded?")] | 1257 | » » [Tooltip("Should·Player·Mouse·assignments·be·saved·and·loaded?")] |
| 1258 | » » [SerializeField] | 1258 | » » [SerializeField] |
| 1259 | » » private·bool·loadMouseAssignments·=·true; | 1259 | » » private·bool·loadMouseAssignments·=·true; |
| 1260 | 1260 | ||
| 1261 | » » [SerializeField] | ||
| 1262 | » » [Tooltip("The·PlayerPrefs·key·prefix.·Change·this·to·change·how·keys·are·stored·in·PlayerPrefs.·Changing·this·will·make·saved·data·already·stored·with·the·old·key·no·longer·accessible.")] | 1261 | » » [Tooltip("The·PlayerPrefs·key·prefix.·Change·this·to·change·how·keys·are·stored·in·PlayerPrefs.·Changing·this·will·make·saved·data·already·stored·with·the·old·key·no·longer·accessible.")] |
| 1262 | » » [SerializeField] | ||
| 1263 | » » private·string·playerPrefsKeyPrefix·=·"RewiredSaveData"; | 1263 | » » private·string·playerPrefsKeyPrefix·=·"RewiredSaveData"; |
| 1264 | 1264 | ||
| 1265 | » » [NonSerialized] | 1265 | » » [NonSerialized] |
| 1266 | » » private·bool·allowImpreciseJoystickAssignmentMatching·=·true; | 1266 | » » private·bool·allowImpreciseJoystickAssignmentMatching·=·true; |
| 1267 | 1267 | ||
| 1268 | » » [NonSerialized] | 1268 | » » [NonSerialized] |
| 1269 | » » private·bool·deferredJoystickAssignmentLoadPending; | 1269 | » » private·bool·deferredJoystickAssignmentLoadPending; |
| Offset 1, 14 lines modified | Offset 1, 14 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·UnityEngine; | 2 | using·UnityEngine; |
| 3 | 3 | ||
| 4 | namespace·Rewired.Demos | 4 | namespace·Rewired.Demos |
| 5 | { | 5 | { |
| 6 | » [AddComponentMenu("")] | ||
| 7 | » [RequireComponent(typeof(CharacterController))] | 6 | » [RequireComponent(typeof(CharacterController))] |
| 7 | » [AddComponentMenu("")] | ||
| 8 | » public·class·PressAnyButtonToJoinExample_GamePlayer·:·MonoBehaviour | 8 | » public·class·PressAnyButtonToJoinExample_GamePlayer·:·MonoBehaviour |
| 9 | » { | 9 | » { |
| 10 | » » private·Player·player | 10 | » » private·Player·player |
| 11 | » » { | 11 | » » { |
| 12 | » » » get | 12 | » » » get |
| 13 | » » » { | 13 | » » » { |
| 14 | » » » » if·(!ReInput.isReady) | 14 | » » » » if·(!ReInput.isReady) |
| Offset 1, 14 lines modified | Offset 1, 14 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·UnityEngine; | 2 | using·UnityEngine; |
| 3 | 3 | ||
| 4 | namespace·Rewired.Demos | 4 | namespace·Rewired.Demos |
| 5 | { | 5 | { |
| 6 | » [AddComponentMenu("")] | ||
| 7 | » [RequireComponent(typeof(CharacterController))] | 6 | » [RequireComponent(typeof(CharacterController))] |
| 7 | » [AddComponentMenu("")] | ||
| 8 | » public·class·PressStartToJoinExample_GamePlayer·:·MonoBehaviour | 8 | » public·class·PressStartToJoinExample_GamePlayer·:·MonoBehaviour |
| 9 | » { | 9 | » { |
| 10 | » » private·Player·player | 10 | » » private·Player·player |
| 11 | » » { | 11 | » » { |
| 12 | » » » get | 12 | » » » get |
| 13 | » » » { | 13 | » » » { |
| 14 | » » » » return·PressStartToJoinExample_Assigner.GetRewiredPlayer(this.gamePlayerId); | 14 | » » » » return·PressStartToJoinExample_Assigner.GetRewiredPlayer(this.gamePlayerId); |
| Offset 1, 16 lines modified | Offset 1, 16 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·UnityEngine; | 2 | using·UnityEngine; |
| 3 | using·UnityEngine.EventSystems; | 3 | using·UnityEngine.EventSystems; |
| 4 | using·UnityEngine.UI; | 4 | using·UnityEngine.UI; |
| 5 | 5 | ||
| 6 | namespace·Rewired.Demos | 6 | namespace·Rewired.Demos |
| 7 | { | 7 | { |
| 8 | » [RequireComponent(typeof(RectTransform))] | ||
| 9 | » [AddComponentMenu("")] | 8 | » [AddComponentMenu("")] |
| 9 | » [RequireComponent(typeof(RectTransform))] | ||
| 10 | » public·sealed·class·UIPointer·:·UIBehaviour | 10 | » public·sealed·class·UIPointer·:·UIBehaviour |
| 11 | » { | 11 | » { |
| 12 | » » public·bool·autoSort | 12 | » » public·bool·autoSort |
| 13 | » » { | 13 | » » { |
| 14 | » » » get | 14 | » » » get |
| 15 | » » » { | 15 | » » » { |
| 16 | » » » » return·this._autoSort; | 16 | » » » » return·this._autoSort; |
| Offset 4, 16 lines modified | Offset 4, 16 lines modified | ||
| 4 | using·Rewired.Utils; | 4 | using·Rewired.Utils; |
| 5 | using·Rewired.Utils.Interfaces; | 5 | using·Rewired.Utils.Interfaces; |
| 6 | using·UnityEngine; | 6 | using·UnityEngine; |
| 7 | using·UnityEngine.SceneManagement; | 7 | using·UnityEngine.SceneManagement; |
| 8 | 8 | ||
| 9 | namespace·Rewired | 9 | namespace·Rewired |
| 10 | { | 10 | { |
| 11 | » [EditorBrowsable(EditorBrowsableState.Never)] | ||
| 12 | » [AddComponentMenu("Rewired/Input·Manager")] | 11 | » [AddComponentMenu("Rewired/Input·Manager")] |
| 12 | » [EditorBrowsable(EditorBrowsableState.Never)] | ||
| 13 | » public·sealed·class·InputManager·:·InputManager_Base | 13 | » public·sealed·class·InputManager·:·InputManager_Base |
| 14 | » { | 14 | » { |
| 15 | » » protected·override·void·OnInitialized() | 15 | » » protected·override·void·OnInitialized() |
| 16 | » » { | 16 | » » { |
| 17 | » » » this.SubscribeEvents(); | 17 | » » » this.SubscribeEvents(); |
| 18 | » » } | 18 | » » } |
| 19 | 19 | ||
| Offset 40, 12 lines modified | Offset 40, 12 lines modified | ||
| 40 | » » » » » » EventSystem.current·=·current; | 40 | » » » » » » EventSystem.current·=·current; |
| 41 | » » » » » } | 41 | » » » » » } |
| 42 | » » » » } | 42 | » » » » } |
| 43 | » » » } | 43 | » » » } |
| 44 | » » » base.Update(); | 44 | » » » base.Update(); |
| 45 | » » } | 45 | » » } |
| 46 | 46 | ||
| 47 | » » [SerializeField] | ||
| 48 | » » [Tooltip("If·enabled,·the·Event·System·will·be·updated·every·frame·even·if·other·Event·Systems·are·enabled.·Otherwise,·only·EventSystem.current·will·be·updated.")] | 47 | » » [Tooltip("If·enabled,·the·Event·System·will·be·updated·every·frame·even·if·other·Event·Systems·are·enabled.·Otherwise,·only·EventSystem.current·will·be·updated.")] |
| 48 | » » [SerializeField] | ||
| 49 | » » private·bool·_alwaysUpdate; | 49 | » » private·bool·_alwaysUpdate; |
| 50 | » } | 50 | » } |
| 51 | } | 51 | } |
| Offset 1281, 36 lines modified | Offset 1281, 36 lines modified | ||
| 1281 | 1281 | ||
| 1282 | » » private·const·string·DEFAULT_ACTION_CANCEL·=·"UICancel"; | 1282 | » » private·const·string·DEFAULT_ACTION_CANCEL·=·"UICancel"; |
| 1283 | 1283 | ||
| 1284 | » » [Tooltip("(Optional)·Link·the·Rewired·Input·Manager·here·for·easier·access·to·Player·ids,·etc.")] | 1284 | » » [Tooltip("(Optional)·Link·the·Rewired·Input·Manager·here·for·easier·access·to·Player·ids,·etc.")] |
| 1285 | » » [SerializeField] | 1285 | » » [SerializeField] |
| 1286 | » » private·InputManager_Base·rewiredInputManager; | 1286 | » » private·InputManager_Base·rewiredInputManager; |
| 1287 | 1287 | ||
| 1288 | » » [SerializeField] | ||
| 1289 | » » [Tooltip("Use·all·Rewired·game·Players·to·control·the·UI.·This·does·not·include·the·System·Player.·If·enabled,·this·setting·overrides·individual·Player·Ids·set·in·Rewired·Player·Ids.")] | 1288 | » » [Tooltip("Use·all·Rewired·game·Players·to·control·the·UI.·This·does·not·include·the·System·Player.·If·enabled,·this·setting·overrides·individual·Player·Ids·set·in·Rewired·Player·Ids.")] |
| 1289 | » » [SerializeField] | ||
| 1290 | » » private·bool·useAllRewiredGamePlayers; | 1290 | » » private·bool·useAllRewiredGamePlayers; |
| 1291 | 1291 | ||
| 1292 | » » [Tooltip("Allow·the·Rewired·System·Player·to·control·the·UI.")] | ||
| 1293 | » » [SerializeField] | 1292 | » » [SerializeField] |
| 1293 | » » [Tooltip("Allow·the·Rewired·System·Player·to·control·the·UI.")] | ||
| 1294 | » » private·bool·useRewiredSystemPlayer; | 1294 | » » private·bool·useRewiredSystemPlayer; |
| 1295 | 1295 | ||
| 1296 | » » [Tooltip("A·list·of·Player·Ids·that·are·allowed·to·control·the·UI.·If·Use·All·Rewired·Game·Players·=·True,·this·list·will·be·ignored.")] | 1296 | » » [Tooltip("A·list·of·Player·Ids·that·are·allowed·to·control·the·UI.·If·Use·All·Rewired·Game·Players·=·True,·this·list·will·be·ignored.")] |
| 1297 | » » [SerializeField] | 1297 | » » [SerializeField] |
| 1298 | » » private·int[]·rewiredPlayerIds·=·new·int[1]; | 1298 | » » private·int[]·rewiredPlayerIds·=·new·int[1]; |
| 1299 | 1299 | ||
| 1300 | » » [SerializeField] | ||
| 1301 | » » [Tooltip("Allow·only·Players·with·Player.isPlaying·=·true·to·control·the·UI.")] | 1300 | » » [Tooltip("Allow·only·Players·with·Player.isPlaying·=·true·to·control·the·UI.")] |
| 1301 | » » [SerializeField] | ||
| 1302 | » » private·bool·usePlayingPlayersOnly; | 1302 | » » private·bool·usePlayingPlayersOnly; |
| 1303 | 1303 | ||
| 1304 | » » [Tooltip("Player·Mice·allowed·to·interact·with·the·UI.·Each·Player·that·owns·a·Player·Mouse·must·also·be·allowed·to·control·the·UI·or·the·Player·Mouse·will·not·function.")] | 1304 | » » [Tooltip("Player·Mice·allowed·to·interact·with·the·UI.·Each·Player·that·owns·a·Player·Mouse·must·also·be·allowed·to·control·the·UI·or·the·Player·Mouse·will·not·function.")] |
| 1305 | » » [SerializeField] | 1305 | » » [SerializeField] |
| 1306 | » » private·List<PlayerMouse>·playerMice·=·new·List<PlayerMouse>(); | 1306 | » » private·List<PlayerMouse>·playerMice·=·new·List<PlayerMouse>(); |
| 1307 | 1307 | ||
| 1308 | » » [Tooltip("Makes·an·axis·press·always·move·only·one·UI·selection.·Enable·if·you·do·not·want·to·allow·scrolling·through·UI·elements·by·holding·an·axis·direction.")] | ||
| 1309 | » » [SerializeField] | 1308 | » » [SerializeField] |
| 1309 | » » [Tooltip("Makes·an·axis·press·always·move·only·one·UI·selection.·Enable·if·you·do·not·want·to·allow·scrolling·through·UI·elements·by·holding·an·axis·direction.")] | ||
| 1310 | » » private·bool·moveOneElementPerAxisPress; | 1310 | » » private·bool·moveOneElementPerAxisPress; |
| 1311 | 1311 | ||
| 1312 | » » [Tooltip("If·enabled,·Action·Ids·will·be·used·to·set·the·Actions.·If·disabled,·string·names·will·be·used·to·set·the·Actions.")] | 1312 | » » [Tooltip("If·enabled,·Action·Ids·will·be·used·to·set·the·Actions.·If·disabled,·string·names·will·be·used·to·set·the·Actions.")] |
| 1313 | » » [SerializeField] | 1313 | » » [SerializeField] |
| 1314 | » » private·bool·setActionsById; | 1314 | » » private·bool·setActionsById; |
| 1315 | 1315 | ||
| 1316 | » » [SerializeField] | 1316 | » » [SerializeField] |
| Offset 1321, 16 lines modified | Offset 1321, 16 lines modified | ||
| 1321 | » » [Tooltip("Id·of·the·vertical·Action·for·movement·(if·axis·events·are·used).")] | 1321 | » » [Tooltip("Id·of·the·vertical·Action·for·movement·(if·axis·events·are·used).")] |
| 1322 | » » private·int·verticalActionId·=·-1; | 1322 | » » private·int·verticalActionId·=·-1; |
| 1323 | 1323 | ||
| 1324 | » » [SerializeField] | 1324 | » » [SerializeField] |
| 1325 | » » [Tooltip("Id·of·the·Action·used·to·submit.")] | 1325 | » » [Tooltip("Id·of·the·Action·used·to·submit.")] |
| 1326 | » » private·int·submitActionId·=·-1; | 1326 | » » private·int·submitActionId·=·-1; |
| 1327 | 1327 | ||
| 1328 | » » [Tooltip("Id·of·the·Action·used·to·cancel.")] | ||
| 1329 | » » [SerializeField] | 1328 | » » [SerializeField] |
| 1329 | » » [Tooltip("Id·of·the·Action·used·to·cancel.")] | ||
| 1330 | » » private·int·cancelActionId·=·-1; | 1330 | » » private·int·cancelActionId·=·-1; |
| 1331 | 1331 | ||
| 1332 | » » [Tooltip("Name·of·the·horizontal·axis·for·movement·(if·axis·events·are·used).")] | 1332 | » » [Tooltip("Name·of·the·horizontal·axis·for·movement·(if·axis·events·are·used).")] |
| 1333 | » » [SerializeField] | 1333 | » » [SerializeField] |
| 1334 | » » private·string·m_HorizontalAxis·=·"UIHorizontal"; | 1334 | » » private·string·m_HorizontalAxis·=·"UIHorizontal"; |
| 1335 | 1335 | ||
| 1336 | » » [SerializeField] | 1336 | » » [SerializeField] |
| Offset 1353, 33 lines modified | Offset 1353, 33 lines modified | ||
| 1353 | » » [SerializeField] | 1353 | » » [SerializeField] |
| 1354 | » » private·float·m_RepeatDelay; | 1354 | » » private·float·m_RepeatDelay; |
| 1355 | 1355 | ||
| 1356 | » » [SerializeField] | 1356 | » » [SerializeField] |
| 1357 | » » [Tooltip("Allows·the·mouse·to·be·used·to·select·elements.")] | 1357 | » » [Tooltip("Allows·the·mouse·to·be·used·to·select·elements.")] |
| 1358 | » » private·bool·m_allowMouseInput·=·true; | 1358 | » » private·bool·m_allowMouseInput·=·true; |
| 1359 | 1359 | ||
| 1360 | » » [SerializeField] | ||
| 1361 | » » [Tooltip("Allows·the·mouse·to·be·used·to·select·elements·if·the·device·also·supports·touch·control.")] | 1360 | » » [Tooltip("Allows·the·mouse·to·be·used·to·select·elements·if·the·device·also·supports·touch·control.")] |
| 1361 | » » [SerializeField] | ||
| 1362 | » » private·bool·m_allowMouseInputIfTouchSupported·=·true; | 1362 | » » private·bool·m_allowMouseInputIfTouchSupported·=·true; |
| 1363 | 1363 | ||
| 1364 | » » [SerializeField] | ||
| 1365 | » » [Tooltip("Allows·touch·input·to·be·used·to·select·elements.")] | 1364 | » » [Tooltip("Allows·touch·input·to·be·used·to·select·elements.")] |
| 1365 | » » [SerializeField] | ||
| 1366 | » » private·bool·m_allowTouchInput·=·true; | 1366 | » » private·bool·m_allowTouchInput·=·true; |
| 1367 | 1367 | ||
| 1368 | » » [SerializeField] | ||
| 1369 | » » [Tooltip("Deselects·the·current·selection·on·mouse/touch·click·when·the·pointer·is·not·over·a·selectable·object.")] | 1368 | » » [Tooltip("Deselects·the·current·selection·on·mouse/touch·click·when·the·pointer·is·not·over·a·selectable·object.")] |
| 1369 | » » [SerializeField] | ||
| 1370 | » » private·bool·m_deselectIfBackgroundClicked·=·true; | 1370 | » » private·bool·m_deselectIfBackgroundClicked·=·true; |
| 1371 | 1371 | ||
| 1372 | » » [SerializeField] | ||
| 1373 | » » [Tooltip("Deselects·the·current·selection·on·mouse/touch·click·before·selecting·the·next·object.")] | 1372 | » » [Tooltip("Deselects·the·current·selection·on·mouse/touch·click·before·selecting·the·next·object.")] |
| 1373 | » » [SerializeField] | ||
| 1374 | » » private·bool·m_deselectBeforeSelecting·=·true; | 1374 | » » private·bool·m_deselectBeforeSelecting·=·true; |
| 1375 | 1375 | ||
| 1376 | » » [Tooltip("Forces·the·module·to·always·be·active.")] | 1376 | » » [Tooltip("Forces·the·module·to·always·be·active.")] |
| 1377 | » » [SerializeField] | ||
| 1378 | » » [FormerlySerializedAs("m_AllowActivationOnMobileDevice")] | 1377 | » » [FormerlySerializedAs("m_AllowActivationOnMobileDevice")] |
| 1378 | » » [SerializeField] | ||
| 1379 | » » private·bool·m_ForceModuleActive; | 1379 | » » private·bool·m_ForceModuleActive; |
| 1380 | 1380 | ||
| 1381 | » » [NonSerialized] | 1381 | » » [NonSerialized] |
| 1382 | » » private·int[]·playerIds; | 1382 | » » private·int[]·playerIds; |
| 1383 | 1383 | ||
| 1384 | » » private·bool·recompiling; | 1384 | » » private·bool·recompiling; |
| 1385 | 1385 | ||
| Offset 493, 16 lines modified | Offset 493, 16 lines modified | ||
| 493 | » » » » { | 493 | » » » » { |
| 494 | » » » » » return·false; | 494 | » » » » » return·false; |
| 495 | » » » » } | 495 | » » » » } |
| 496 | » » » » action(value); | 496 | » » » » action(value); |
| 497 | » » » » return·true; | 497 | » » » » return·true; |
| 498 | » » » } | 498 | » » » } |
| 499 | 499 | ||
| 500 | » » » [Tooltip("Determines·whether·this·Npad·id·is·allowed·to·be·used·by·the·system.")] | ||
| 501 | » » » [SerializeField] | 500 | » » » [SerializeField] |
| 501 | » » » [Tooltip("Determines·whether·this·Npad·id·is·allowed·to·be·used·by·the·system.")] | ||
| 502 | » » » private·bool·_isAllowed·=·true; | 502 | » » » private·bool·_isAllowed·=·true; |
| 503 | 503 | ||
| 504 | » » » [Tooltip("The·Rewired·Player·Id·assigned·to·this·Npad·id.")] | 504 | » » » [Tooltip("The·Rewired·Player·Id·assigned·to·this·Npad·id.")] |
| 505 | » » » [SerializeField] | 505 | » » » [SerializeField] |
| 506 | » » » private·int·_rewiredPlayerId; | 506 | » » » private·int·_rewiredPlayerId; |
| 507 | 507 | ||
| 508 | » » » [Tooltip("Determines·how·Joy-Cons·should·be·handled.\n\nUnmodified:·Joy-Con·assignment·mode·will·be·left·at·the·system·default.\nDual:·Joy-Cons·pairs·are·handled·as·a·single·controller.\nSingle:·Joy-Cons·are·handled·as·individual·controllers.")] | 508 | » » » [Tooltip("Determines·how·Joy-Cons·should·be·handled.\n\nUnmodified:·Joy-Con·assignment·mode·will·be·left·at·the·system·default.\nDual:·Joy-Cons·pairs·are·handled·as·a·single·controller.\nSingle:·Joy-Cons·are·handled·as·individual·controllers.")] |
| Offset 610, 16 lines modified | Offset 610, 16 lines modified | ||
| 610 | » » » » { | 610 | » » » » { |
| 611 | » » » » » return·false; | 611 | » » » » » return·false; |
| 612 | » » » » } | 612 | » » » » } |
| 613 | » » » » action(value); | 613 | » » » » action(value); |
| 614 | » » » » return·true; | 614 | » » » » return·true; |
| 615 | » » » } | 615 | » » » } |
| 616 | 616 | ||
| 617 | » » » [SerializeField] | ||
| 618 | » » » [Tooltip("Determines·whether·the·Debug·Pad·will·be·enabled.")] | 617 | » » » [Tooltip("Determines·whether·the·Debug·Pad·will·be·enabled.")] |
| 618 | » » » [SerializeField] | ||
| 619 | » » » private·bool·_enabled; | 619 | » » » private·bool·_enabled; |
| 620 | 620 | ||
| 621 | » » » [Tooltip("The·Rewired·Player·Id·to·which·the·Debug·Pad·will·be·assigned.")] | 621 | » » » [Tooltip("The·Rewired·Player·Id·to·which·the·Debug·Pad·will·be·assigned.")] |
| 622 | » » » [SerializeField] | 622 | » » » [SerializeField] |
| 623 | » » » private·int·_rewiredPlayerId; | 623 | » » » private·int·_rewiredPlayerId; |
| 624 | 624 | ||
| 625 | » » » private·Dictionary<int,·object[]>·__delegates; | 625 | » » » private·Dictionary<int,·object[]>·__delegates; |
| Offset 4319, 95 lines modified | Offset 4319, 95 lines modified | ||
| 4319 | 4319 | ||
| 4320 | » » private·const·string·buttonIdentifier_assignedControllerSelection·=·"AssignedControllerSelection"; | 4320 | » » private·const·string·buttonIdentifier_assignedControllerSelection·=·"AssignedControllerSelection"; |
| 4321 | 4321 | ||
| 4322 | » » private·const·string·buttonIdentifier_done·=·"Done"; | 4322 | » » private·const·string·buttonIdentifier_done·=·"Done"; |
| 4323 | 4323 | ||
| 4324 | » » private·const·string·buttonIdentifier_restoreDefaults·=·"RestoreDefaults"; | 4324 | » » private·const·string·buttonIdentifier_restoreDefaults·=·"RestoreDefaults"; |
| 4325 | 4325 | ||
| 4326 | » » [Tooltip("Must·be·assigned·a·Rewired·Input·Manager·scene·object·or·prefab.")] | ||
| 4327 | » » [SerializeField] | 4326 | » » [SerializeField] |
| 4327 | » » [Tooltip("Must·be·assigned·a·Rewired·Input·Manager·scene·object·or·prefab.")] | ||
| 4328 | » » private·InputManager·_rewiredInputManager; | 4328 | » » private·InputManager·_rewiredInputManager; |
| 4329 | 4329 | ||
| 4330 | » » [SerializeField] | ||
| 4331 | » » [Tooltip("Set·to·True·to·prevent·the·Game·Object·from·being·destroyed·when·a·new·scene·is·loaded.\n\nNOTE:·Changing·this·value·from·True·to·False·at·runtime·will·have·no·effect·because·Object.DontDestroyOnLoad·cannot·be·undone·once·set.")] | 4330 | » » [Tooltip("Set·to·True·to·prevent·the·Game·Object·from·being·destroyed·when·a·new·scene·is·loaded.\n\nNOTE:·Changing·this·value·from·True·to·False·at·runtime·will·have·no·effect·because·Object.DontDestroyOnLoad·cannot·be·undone·once·set.")] |
| 4331 | » » [SerializeField] | ||
| 4332 | » » private·bool·_dontDestroyOnLoad; | 4332 | » » private·bool·_dontDestroyOnLoad; |
| 4333 | 4333 | ||
| 4334 | » » [SerializeField] | 4334 | » » [SerializeField] |
| 4335 | » » [Tooltip("Open·the·control·mapping·screen·immediately·on·start.·Mainly·used·for·testing.")] | 4335 | » » [Tooltip("Open·the·control·mapping·screen·immediately·on·start.·Mainly·used·for·testing.")] |
| 4336 | » » private·bool·_openOnStart; | 4336 | » » private·bool·_openOnStart; |
| 4337 | 4337 | ||
| 4338 | » » [SerializeField] | 4338 | » » [SerializeField] |
| 4339 | » » [Tooltip("The·Layout·of·the·Keyboard·Maps·to·be·displayed.")] | 4339 | » » [Tooltip("The·Layout·of·the·Keyboard·Maps·to·be·displayed.")] |
| 4340 | » » private·int·_keyboardMapDefaultLayout; | 4340 | » » private·int·_keyboardMapDefaultLayout; |
| 4341 | 4341 | ||
| 4342 | » » [Tooltip("The·Layout·of·the·Mouse·Maps·to·be·displayed.")] | 4342 | » » [Tooltip("The·Layout·of·the·Mouse·Maps·to·be·displayed.")] |
| 4343 | » » [SerializeField] | 4343 | » » [SerializeField] |
| 4344 | » » private·int·_mouseMapDefaultLayout; | 4344 | » » private·int·_mouseMapDefaultLayout; |
| 4345 | 4345 | ||
| 4346 | » » [Tooltip("The·Layout·of·the·Mouse·Maps·to·be·displayed.")] | ||
| 4347 | » » [SerializeField] | 4346 | » » [SerializeField] |
| 4347 | » » [Tooltip("The·Layout·of·the·Mouse·Maps·to·be·displayed.")] | ||
| 4348 | » » private·int·_joystickMapDefaultLayout; | 4348 | » » private·int·_joystickMapDefaultLayout; |
| 4349 | 4349 | ||
| 4350 | » » [SerializeField] | 4350 | » » [SerializeField] |
| 4351 | » » private·ControlMapper.MappingSet[]·_mappingSets·=·new·ControlMapper.MappingSet[]·{·ControlMapper.MappingSet.Default·}; | 4351 | » » private·ControlMapper.MappingSet[]·_mappingSets·=·new·ControlMapper.MappingSet[]·{·ControlMapper.MappingSet.Default·}; |
| 4352 | 4352 | ||
| 4353 | » » [Tooltip("Display·a·selectable·list·of·Players.·If·your·game·only·supports·1·player,·you·can·disable·this.")] | 4353 | » » [Tooltip("Display·a·selectable·list·of·Players.·If·your·game·only·supports·1·player,·you·can·disable·this.")] |
| 4354 | » » [SerializeField] | 4354 | » » [SerializeField] |
| 4355 | » » private·bool·_showPlayers·=·true; | 4355 | » » private·bool·_showPlayers·=·true; |
| 4356 | 4356 | ||
| 4357 | » » [SerializeField] | ||
| 4358 | » » [Tooltip("Display·the·Controller·column·for·input·mapping.")] | 4357 | » » [Tooltip("Display·the·Controller·column·for·input·mapping.")] |
| 4358 | » » [SerializeField] | ||
| 4359 | » » private·bool·_showControllers·=·true; | 4359 | » » private·bool·_showControllers·=·true; |
| 4360 | 4360 | ||
| 4361 | » » [SerializeField] | ||
| 4362 | » » [Tooltip("Display·the·Keyboard·column·for·input·mapping.")] | 4361 | » » [Tooltip("Display·the·Keyboard·column·for·input·mapping.")] |
| 4362 | » » [SerializeField] | ||
| 4363 | » » private·bool·_showKeyboard·=·true; | 4363 | » » private·bool·_showKeyboard·=·true; |
| 4364 | 4364 | ||
| 4365 | » » [SerializeField] | 4365 | » » [SerializeField] |
| 4366 | » » [Tooltip("Display·the·Mouse·column·for·input·mapping.")] | 4366 | » » [Tooltip("Display·the·Mouse·column·for·input·mapping.")] |
| 4367 | » » private·bool·_showMouse·=·true; | 4367 | » » private·bool·_showMouse·=·true; |
| 4368 | 4368 | ||
| 4369 | » » [SerializeField] | 4369 | » » [SerializeField] |
| 4370 | » » [Tooltip("The·maximum·number·of·controllers·allowed·to·be·assigned·to·a·Player.·If·set·to·any·value·other·than·1,·a·selectable·list·of·currently-assigned·controller·will·be·displayed·to·the·user.·[0·=·infinite]")] | 4370 | » » [Tooltip("The·maximum·number·of·controllers·allowed·to·be·assigned·to·a·Player.·If·set·to·any·value·other·than·1,·a·selectable·list·of·currently-assigned·controller·will·be·displayed·to·the·user.·[0·=·infinite]")] |
| 4371 | » » private·int·_maxControllersPerPlayer·=·1; | 4371 | » » private·int·_maxControllersPerPlayer·=·1; |
| 4372 | 4372 | ||
| 4373 | » » [Tooltip("Display·section·labels·for·each·Action·Category·in·the·input·field·grid.·Only·applies·if·Action·Categories·are·used·to·display·the·Action·list.")] | 4373 | » » [Tooltip("Display·section·labels·for·each·Action·Category·in·the·input·field·grid.·Only·applies·if·Action·Categories·are·used·to·display·the·Action·list.")] |
| 4374 | » » [SerializeField] | 4374 | » » [SerializeField] |
| 4375 | » » private·bool·_showActionCategoryLabels; | 4375 | » » private·bool·_showActionCategoryLabels; |
| 4376 | 4376 | ||
| 4377 | » » [SerializeField] | ||
| 4378 | » » [Tooltip("The·number·of·input·fields·to·display·for·the·keyboard.·If·you·want·to·support·alternate·mappings·on·the·same·device,·set·this·to·2·or·more.")] | 4377 | » » [Tooltip("The·number·of·input·fields·to·display·for·the·keyboard.·If·you·want·to·support·alternate·mappings·on·the·same·device,·set·this·to·2·or·more.")] |
| 4378 | » » [SerializeField] | ||
| 4379 | » » private·int·_keyboardInputFieldCount·=·2; | 4379 | » » private·int·_keyboardInputFieldCount·=·2; |
| 4380 | 4380 | ||
| 4381 | » » [Tooltip("The·number·of·input·fields·to·display·for·the·mouse.·If·you·want·to·support·alternate·mappings·on·the·same·device,·set·this·to·2·or·more.")] | ||
| 4382 | » » [SerializeField] | 4381 | » » [SerializeField] |
| 4382 | » » [Tooltip("The·number·of·input·fields·to·display·for·the·mouse.·If·you·want·to·support·alternate·mappings·on·the·same·device,·set·this·to·2·or·more.")] | ||
| 4383 | » » private·int·_mouseInputFieldCount·=·1; | 4383 | » » private·int·_mouseInputFieldCount·=·1; |
| 4384 | 4384 | ||
| 4385 | » » [Tooltip("The·number·of·input·fields·to·display·for·joysticks.·If·you·want·to·support·alternate·mappings·on·the·same·device,·set·this·to·2·or·more.")] | 4385 | » » [Tooltip("The·number·of·input·fields·to·display·for·joysticks.·If·you·want·to·support·alternate·mappings·on·the·same·device,·set·this·to·2·or·more.")] |
| 4386 | » » [SerializeField] | 4386 | » » [SerializeField] |
| 4387 | » » private·int·_controllerInputFieldCount·=·1; | 4387 | » » private·int·_controllerInputFieldCount·=·1; |
| 4388 | 4388 | ||
| 4389 | » » [Tooltip("Display·a·full-axis·input·assignment·field·for·every·axis-type·Action·in·the·input·field·grid.·Also·displays·an·invert·toggle·for·the·user··to·invert·the·full-axis·assignment·direction.\n\n*IMPORTANT*:·This·field·is·required·if·you·have·made·any·full-axis·assignments·in·the·Rewired·Input·Manager·or·in·saved·XML·user·data.·Disabling·this·field·when·you·have·full-axis·assignments·will·result·in·the·inability·for·the·user·to·view,·remove,·or·modify·these·full-axis·assignments.·In·addition,·these·assignments·may·cause·conflicts·when·trying·to·remap·the·same·axes·to·Actions.")] | 4389 | » » [Tooltip("Display·a·full-axis·input·assignment·field·for·every·axis-type·Action·in·the·input·field·grid.·Also·displays·an·invert·toggle·for·the·user··to·invert·the·full-axis·assignment·direction.\n\n*IMPORTANT*:·This·field·is·required·if·you·have·made·any·full-axis·assignments·in·the·Rewired·Input·Manager·or·in·saved·XML·user·data.·Disabling·this·field·when·you·have·full-axis·assignments·will·result·in·the·inability·for·the·user·to·view,·remove,·or·modify·these·full-axis·assignments.·In·addition,·these·assignments·may·cause·conflicts·when·trying·to·remap·the·same·axes·to·Actions.")] |
| 4390 | » » [SerializeField] | 4390 | » » [SerializeField] |
| 4391 | » » private·bool·_showFullAxisInputFields·=·true; | 4391 | » » private·bool·_showFullAxisInputFields·=·true; |
| 4392 | 4392 | ||
| 4393 | » » [Tooltip("Display·a·positive·and·negative·input·assignment·field·for·every·axis-type·Action·in·the·input·field·grid.\n\n*IMPORTANT*:·These·fields·are·required·to·assign·buttons,·keyboard·keys,·and·hat·or·D-Pad·directions·to·axis-type·Actions.·If·you·have·made·any·split-axis·assignments·or·button/key/D-pad·assignments·to·axis-type·Actions·in·the·Rewired·Input·Manager·or·in·saved·XML·user·data,·disabling·these·fields·will·result·in·the·inability·for·the·user·to·view,·remove,·or·modify·these·assignments.·In·addition,·these·assignments·may·cause·conflicts·when·trying·to·remap·the·same·elements·to·Actions.")] | ||
| 4394 | » » [SerializeField] | 4393 | » » [SerializeField] |
| 4394 | » » [Tooltip("Display·a·positive·and·negative·input·assignment·field·for·every·axis-type·Action·in·the·input·field·grid.\n\n*IMPORTANT*:·These·fields·are·required·to·assign·buttons,·keyboard·keys,·and·hat·or·D-Pad·directions·to·axis-type·Actions.·If·you·have·made·any·split-axis·assignments·or·button/key/D-pad·assignments·to·axis-type·Actions·in·the·Rewired·Input·Manager·or·in·saved·XML·user·data,·disabling·these·fields·will·result·in·the·inability·for·the·user·to·view,·remove,·or·modify·these·assignments.·In·addition,·these·assignments·may·cause·conflicts·when·trying·to·remap·the·same·elements·to·Actions.")] | ||
| 4395 | » » private·bool·_showSplitAxisInputFields·=·true; | 4395 | » » private·bool·_showSplitAxisInputFields·=·true; |
| 4396 | 4396 | ||
| 4397 | » » [Tooltip("If·enabled,·when·an·element·assignment·conflict·is·found,·an·option·will·be·displayed·that·allows·the·user·to·make·the·conflicting·assignment·anyway.")] | ||
| 4398 | » » [SerializeField] | 4397 | » » [SerializeField] |
| 4398 | » » [Tooltip("If·enabled,·when·an·element·assignment·conflict·is·found,·an·option·will·be·displayed·that·allows·the·user·to·make·the·conflicting·assignment·anyway.")] | ||
| 4399 | » » private·bool·_allowElementAssignmentConflicts; | 4399 | » » private·bool·_allowElementAssignmentConflicts; |
| 4400 | 4400 | ||
| 4401 | » » [Tooltip("If·enabled,·when·an·element·assignment·conflict·is·found,·an·option·will·be·displayed·that·allows·the·user·to·swap·conflicting·assignments.·This·only·applies·to·the·first·conflicting·assignment·found.·This·option·will·not·be·displayed·if·allowElementAssignmentConflicts·is·true.")] | 4401 | » » [Tooltip("If·enabled,·when·an·element·assignment·conflict·is·found,·an·option·will·be·displayed·that·allows·the·user·to·swap·conflicting·assignments.·This·only·applies·to·the·first·conflicting·assignment·found.·This·option·will·not·be·displayed·if·allowElementAssignmentConflicts·is·true.")] |
| 4402 | » » [SerializeField] | 4402 | » » [SerializeField] |
| 4403 | » » private·bool·_allowElementAssignmentSwap; | 4403 | » » private·bool·_allowElementAssignmentSwap; |
| 4404 | 4404 | ||
| 4405 | » » [Tooltip("The·width·in·relative·pixels·of·the·Action·label·column.")] | ||
| 4406 | » » [SerializeField] | 4405 | » » [SerializeField] |
| 4406 | » » [Tooltip("The·width·in·relative·pixels·of·the·Action·label·column.")] | ||
| 4407 | » » private·int·_actionLabelWidth·=·200; | 4407 | » » private·int·_actionLabelWidth·=·200; |
| 4408 | 4408 | ||
| 4409 | » » [SerializeField] | 4409 | » » [SerializeField] |
| 4410 | » » [Tooltip("The·width·in·relative·pixels·of·the·Keyboard·column.")] | 4410 | » » [Tooltip("The·width·in·relative·pixels·of·the·Keyboard·column.")] |
| 4411 | » » private·int·_keyboardColMaxWidth·=·360; | 4411 | » » private·int·_keyboardColMaxWidth·=·360; |
| 4412 | 4412 | ||
| 4413 | » » [Tooltip("The·width·in·relative·pixels·of·the·Mouse·column.")] | 4413 | » » [Tooltip("The·width·in·relative·pixels·of·the·Mouse·column.")] |
| Offset 4418, 16 lines modified | Offset 4418, 16 lines modified | ||
| 4418 | » » [Tooltip("The·width·in·relative·pixels·of·the·Controller·column.")] | 4418 | » » [Tooltip("The·width·in·relative·pixels·of·the·Controller·column.")] |
| 4419 | » » private·int·_controllerColMaxWidth·=·200; | 4419 | » » private·int·_controllerColMaxWidth·=·200; |
| 4420 | 4420 | ||
| 4421 | » » [SerializeField] | 4421 | » » [SerializeField] |
| 4422 | » » [Tooltip("The·height·in·relative·pixels·of·the·input·grid·button·rows.")] | 4422 | » » [Tooltip("The·height·in·relative·pixels·of·the·input·grid·button·rows.")] |
| 4423 | » » private·int·_inputRowHeight·=·40; | 4423 | » » private·int·_inputRowHeight·=·40; |
| 4424 | 4424 | ||
| 4425 | » » [Tooltip("The·padding·of·the·input·grid·button·rows.")] | ||
| 4426 | » » [SerializeField] | 4425 | » » [SerializeField] |
| 4426 | » » [Tooltip("The·padding·of·the·input·grid·button·rows.")] | ||
| 4427 | » » private·RectOffset·_inputRowPadding·=·new·RectOffset(); | 4427 | » » private·RectOffset·_inputRowPadding·=·new·RectOffset(); |
| 4428 | 4428 | ||
| 4429 | » » [SerializeField] | 4429 | » » [SerializeField] |
| 4430 | » » [Tooltip("The·width·in·relative·pixels·of·spacing·between·input·fields·in·a·single·column.")] | 4430 | » » [Tooltip("The·width·in·relative·pixels·of·spacing·between·input·fields·in·a·single·column.")] |
| 4431 | » » private·int·_inputRowFieldSpacing; | 4431 | » » private·int·_inputRowFieldSpacing; |
| 4432 | 4432 | ||
| 4433 | » » [SerializeField] | 4433 | » » [SerializeField] |
| Offset 4442, 20 lines modified | Offset 4442, 20 lines modified | ||
| 4442 | » » [Tooltip("The·width·in·relative·pixels·of·the·invert·toggle·buttons.")] | 4442 | » » [Tooltip("The·width·in·relative·pixels·of·the·invert·toggle·buttons.")] |
| 4443 | » » private·int·_invertToggleWidth·=·40; | 4443 | » » private·int·_invertToggleWidth·=·40; |
| 4444 | 4444 | ||
| Max diff block lines reached; 8797/16356 bytes (53.78%) of diff not shown. | |||
| Offset 661, 39 lines modified | Offset 661, 39 lines modified | ||
| 661 | 661 | ||
| 662 | » » [SerializeField] | 662 | » » [SerializeField] |
| 663 | » » private·string·_assignControllerWindowMessage·=·"Press·any·button·or·move·an·axis·on·the·controller·you·would·like·to·use."; | 663 | » » private·string·_assignControllerWindowMessage·=·"Press·any·button·or·move·an·axis·on·the·controller·you·would·like·to·use."; |
| 664 | 664 | ||
| 665 | » » [SerializeField] | 665 | » » [SerializeField] |
| 666 | » » private·string·_controllerAssignmentConflictWindowTitle·=·"Controller·Assignment"; | 666 | » » private·string·_controllerAssignmentConflictWindowTitle·=·"Controller·Assignment"; |
| 667 | 667 | ||
| 668 | » » [SerializeField] | ||
| 669 | » » [Tooltip("{0}·=·Joystick·Name\n{1}·=·Other·Player·Name\n{2}·=·This·Player·Name")] | 668 | » » [Tooltip("{0}·=·Joystick·Name\n{1}·=·Other·Player·Name\n{2}·=·This·Player·Name")] |
| 669 | » » [SerializeField] | ||
| 670 | » » private·string·_controllerAssignmentConflictWindowMessage·=·"{0}·is·already·assigned·to·{1}.·Do·you·want·to·assign·this·controller·to·{2}·instead?"; | 670 | » » private·string·_controllerAssignmentConflictWindowMessage·=·"{0}·is·already·assigned·to·{1}.·Do·you·want·to·assign·this·controller·to·{2}·instead?"; |
| 671 | 671 | ||
| 672 | » » [SerializeField] | 672 | » » [SerializeField] |
| 673 | » » private·string·_elementAssignmentPrePollingWindowMessage·=·"First·center·or·zero·all·sticks·and·axes·and·press·any·button·or·wait·for·the·timer·to·finish."; | 673 | » » private·string·_elementAssignmentPrePollingWindowMessage·=·"First·center·or·zero·all·sticks·and·axes·and·press·any·button·or·wait·for·the·timer·to·finish."; |
| 674 | 674 | ||
| 675 | » » [Tooltip("{0}·=·Action·Name")] | ||
| 676 | » » [SerializeField] | 675 | » » [SerializeField] |
| 676 | » » [Tooltip("{0}·=·Action·Name")] | ||
| 677 | » » private·string·_joystickElementAssignmentPollingWindowMessage·=·"Now·press·a·button·or·move·an·axis·to·assign·it·to·{0}."; | 677 | » » private·string·_joystickElementAssignmentPollingWindowMessage·=·"Now·press·a·button·or·move·an·axis·to·assign·it·to·{0}."; |
| 678 | 678 | ||
| 679 | » » [Tooltip("This·text·is·only·displayed·when·split-axis·fields·have·been·disabled·and·the·user·clicks·on·the·full-axis·field.·Button/key/D-pad·input·cannot·be·assigned·to·a·full-axis·field.\n{0}·=·Action·Name")] | ||
| 680 | » » [SerializeField] | 679 | » » [SerializeField] |
| 680 | » » [Tooltip("This·text·is·only·displayed·when·split-axis·fields·have·been·disabled·and·the·user·clicks·on·the·full-axis·field.·Button/key/D-pad·input·cannot·be·assigned·to·a·full-axis·field.\n{0}·=·Action·Name")] | ||
| 681 | » » private·string·_joystickElementAssignmentPollingWindowMessage_fullAxisFieldOnly·=·"Now·move·an·axis·to·assign·it·to·{0}."; | 681 | » » private·string·_joystickElementAssignmentPollingWindowMessage_fullAxisFieldOnly·=·"Now·move·an·axis·to·assign·it·to·{0}."; |
| 682 | 682 | ||
| 683 | » » [SerializeField] | 683 | » » [SerializeField] |
| 684 | » » [Tooltip("{0}·=·Action·Name")] | 684 | » » [Tooltip("{0}·=·Action·Name")] |
| 685 | » » private·string·_keyboardElementAssignmentPollingWindowMessage·=·"Press·a·key·to·assign·it·to·{0}.·Modifier·keys·may·also·be·used.·To·assign·a·modifier·key·alone,·hold·it·down·for·1·second."; | 685 | » » private·string·_keyboardElementAssignmentPollingWindowMessage·=·"Press·a·key·to·assign·it·to·{0}.·Modifier·keys·may·also·be·used.·To·assign·a·modifier·key·alone,·hold·it·down·for·1·second."; |
| 686 | 686 | ||
| 687 | » » [SerializeField] | 687 | » » [SerializeField] |
| 688 | » » [Tooltip("{0}·=·Action·Name")] | 688 | » » [Tooltip("{0}·=·Action·Name")] |
| 689 | » » private·string·_mouseElementAssignmentPollingWindowMessage·=·"Press·a·mouse·button·or·move·an·axis·to·assign·it·to·{0}."; | 689 | » » private·string·_mouseElementAssignmentPollingWindowMessage·=·"Press·a·mouse·button·or·move·an·axis·to·assign·it·to·{0}."; |
| 690 | 690 | ||
| 691 | » » [Tooltip("This·text·is·only·displayed·when·split-axis·fields·have·been·disabled·and·the·user·clicks·on·the·full-axis·field.·Button/key/D-pad·input·cannot·be·assigned·to·a·full-axis·field.\n{0}·=·Action·Name")] | ||
| 692 | » » [SerializeField] | 691 | » » [SerializeField] |
| 692 | » » [Tooltip("This·text·is·only·displayed·when·split-axis·fields·have·been·disabled·and·the·user·clicks·on·the·full-axis·field.·Button/key/D-pad·input·cannot·be·assigned·to·a·full-axis·field.\n{0}·=·Action·Name")] | ||
| 693 | » » private·string·_mouseElementAssignmentPollingWindowMessage_fullAxisFieldOnly·=·"Move·an·axis·to·assign·it·to·{0}."; | 693 | » » private·string·_mouseElementAssignmentPollingWindowMessage_fullAxisFieldOnly·=·"Move·an·axis·to·assign·it·to·{0}."; |
| 694 | 694 | ||
| 695 | » » [SerializeField] | 695 | » » [SerializeField] |
| 696 | » » private·string·_elementAssignmentConflictWindowMessage·=·"Assignment·Conflict"; | 696 | » » private·string·_elementAssignmentConflictWindowMessage·=·"Assignment·Conflict"; |
| 697 | 697 | ||
| 698 | » » [SerializeField] | 698 | » » [SerializeField] |
| 699 | » » [Tooltip("{0}·=·Element·Name")] | 699 | » » [Tooltip("{0}·=·Element·Name")] |
| Offset 706, 16 lines modified | Offset 706, 16 lines modified | ||
| 706 | » » [SerializeField] | 706 | » » [SerializeField] |
| 707 | » » [Tooltip("{0}·=·Element·Name")] | 707 | » » [Tooltip("{0}·=·Element·Name")] |
| 708 | » » private·string·_elementAlreadyInUseCanReplace_conflictAllowed·=·"{0}·is·already·in·use.·Do·you·want·to·replace·it?·You·may·also·choose·to·add·the·assignment·anyway."; | 708 | » » private·string·_elementAlreadyInUseCanReplace_conflictAllowed·=·"{0}·is·already·in·use.·Do·you·want·to·replace·it?·You·may·also·choose·to·add·the·assignment·anyway."; |
| 709 | 709 | ||
| 710 | » » [SerializeField] | 710 | » » [SerializeField] |
| 711 | » » private·string·_mouseAssignmentConflictWindowTitle·=·"Mouse·Assignment"; | 711 | » » private·string·_mouseAssignmentConflictWindowTitle·=·"Mouse·Assignment"; |
| 712 | 712 | ||
| 713 | » » [SerializeField] | ||
| 714 | » » [Tooltip("{0}·=·Other·Player·Name\n{1}·=·This·Player·Name")] | 713 | » » [Tooltip("{0}·=·Other·Player·Name\n{1}·=·This·Player·Name")] |
| 714 | » » [SerializeField] | ||
| 715 | » » private·string·_mouseAssignmentConflictWindowMessage·=·"The·mouse·is·already·assigned·to·{0}.·Do·you·want·to·assign·the·mouse·to·{1}·instead?"; | 715 | » » private·string·_mouseAssignmentConflictWindowMessage·=·"The·mouse·is·already·assigned·to·{0}.·Do·you·want·to·assign·the·mouse·to·{1}·instead?"; |
| 716 | 716 | ||
| 717 | » » [SerializeField] | 717 | » » [SerializeField] |
| 718 | » » private·string·_calibrateControllerWindowTitle·=·"Calibrate·Controller"; | 718 | » » private·string·_calibrateControllerWindowTitle·=·"Calibrate·Controller"; |
| 719 | 719 | ||
| 720 | » » [SerializeField] | 720 | » » [SerializeField] |
| 721 | » » private·string·_calibrateAxisStep1WindowTitle·=·"Calibrate·Zero"; | 721 | » » private·string·_calibrateAxisStep1WindowTitle·=·"Calibrate·Zero"; |
| Offset 737, 16 lines modified | Offset 737, 16 lines modified | ||
| 737 | » » [SerializeField] | 737 | » » [SerializeField] |
| 738 | » » private·string·_restoreDefaultsWindowTitle·=·"Restore·Defaults"; | 738 | » » private·string·_restoreDefaultsWindowTitle·=·"Restore·Defaults"; |
| 739 | 739 | ||
| 740 | » » [Tooltip("Message·for·a·single·player·game.")] | 740 | » » [Tooltip("Message·for·a·single·player·game.")] |
| 741 | » » [SerializeField] | 741 | » » [SerializeField] |
| 742 | » » private·string·_restoreDefaultsWindowMessage_onePlayer·=·"This·will·restore·the·default·input·configuration.·Are·you·sure·you·want·to·do·this?"; | 742 | » » private·string·_restoreDefaultsWindowMessage_onePlayer·=·"This·will·restore·the·default·input·configuration.·Are·you·sure·you·want·to·do·this?"; |
| 743 | 743 | ||
| 744 | » » [Tooltip("Message·for·a·multi-player·game.")] | ||
| 745 | » » [SerializeField] | 744 | » » [SerializeField] |
| 745 | » » [Tooltip("Message·for·a·multi-player·game.")] | ||
| 746 | » » private·string·_restoreDefaultsWindowMessage_multiPlayer·=·"This·will·restore·the·default·input·configuration·for·all·players.·Are·you·sure·you·want·to·do·this?"; | 746 | » » private·string·_restoreDefaultsWindowMessage_multiPlayer·=·"This·will·restore·the·default·input·configuration·for·all·players.·Are·you·sure·you·want·to·do·this?"; |
| 747 | 747 | ||
| 748 | » » [SerializeField] | 748 | » » [SerializeField] |
| 749 | » » private·string·_actionColumnLabel·=·"Actions"; | 749 | » » private·string·_actionColumnLabel·=·"Actions"; |
| 750 | 750 | ||
| 751 | » » [SerializeField] | 751 | » » [SerializeField] |
| 752 | » » private·string·_keyboardColumnLabel·=·"Keyboard"; | 752 | » » private·string·_keyboardColumnLabel·=·"Keyboard"; |
| Offset 2, 16 lines modified | Offset 2, 16 lines modified | ||
| 2 | using·Rewired.Utils; | 2 | using·Rewired.Utils; |
| 3 | using·UnityEngine; | 3 | using·UnityEngine; |
| 4 | using·UnityEngine.EventSystems; | 4 | using·UnityEngine.EventSystems; |
| 5 | using·UnityEngine.UI; | 5 | using·UnityEngine.UI; |
| 6 | 6 | ||
| 7 | namespace·Rewired.UI.ControlMapper | 7 | namespace·Rewired.UI.ControlMapper |
| 8 | { | 8 | { |
| 9 | » [AddComponentMenu("")] | ||
| 10 | » [RequireComponent(typeof(Selectable))] | 9 | » [RequireComponent(typeof(Selectable))] |
| 10 | » [AddComponentMenu("")] | ||
| 11 | » public·class·ScrollRectSelectableChild·:·MonoBehaviour,·ISelectHandler,·IEventSystemHandler | 11 | » public·class·ScrollRectSelectableChild·:·MonoBehaviour,·ISelectHandler,·IEventSystemHandler |
| 12 | » { | 12 | » { |
| 13 | » » private·RectTransform·parentScrollRectContentTransform | 13 | » » private·RectTransform·parentScrollRectContentTransform |
| 14 | » » { | 14 | » » { |
| 15 | » » » get | 15 | » » » get |
| 16 | » » » { | 16 | » » » { |
| 17 | » » » » return·this.parentScrollRect.content; | 17 | » » » » return·this.parentScrollRect.content; |
| Offset 1, 15 lines modified | Offset 1, 15 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·UnityEngine; | 2 | using·UnityEngine; |
| 3 | using·UnityEngine.UI; | 3 | using·UnityEngine.UI; |
| 4 | 4 | ||
| 5 | namespace·Rewired.UI.ControlMapper | 5 | namespace·Rewired.UI.ControlMapper |
| 6 | { | 6 | { |
| 7 | » [RequireComponent(typeof(Image))] | ||
| 8 | » [AddComponentMenu("")] | 7 | » [AddComponentMenu("")] |
| 8 | » [RequireComponent(typeof(Image))] | ||
| 9 | » public·class·UIImageHelper·:·MonoBehaviour | 9 | » public·class·UIImageHelper·:·MonoBehaviour |
| 10 | » { | 10 | » { |
| 11 | » » public·void·SetEnabledState(bool·newState) | 11 | » » public·void·SetEnabledState(bool·newState) |
| 12 | » » { | 12 | » » { |
| 13 | » » » this.currentState·=·newState; | 13 | » » » this.currentState·=·newState; |
| 14 | » » » UIImageHelper.State·state·=·(newState·?·this.enabledState·:·this.disabledState); | 14 | » » » UIImageHelper.State·state·=·(newState·?·this.enabledState·:·this.disabledState); |
| 15 | » » » if·(state·==·null) | 15 | » » » if·(state·==·null) |
| Offset 142, 43 lines modified | Offset 142, 40 lines modified | ||
| 142 | 142 | ||
| 143 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"MenuLB")] | 143 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"MenuLB")] |
| 144 | » » public·const·int·MenuLB·=·52; | 144 | » » public·const·int·MenuLB·=·52; |
| 145 | 145 | ||
| 146 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"MenuRB")] | 146 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"MenuRB")] |
| 147 | » » public·const·int·MenuRB·=·53; | 147 | » » public·const·int·MenuRB·=·53; |
| 148 | 148 | ||
| 149 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug | 149 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug·Next·Page")] |
| 150 | » » public·const·int·Debug | 150 | » » public·const·int·DebugPageNext·=·56; |
| 151 | 151 | ||
| 152 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug | 152 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug·Previous·Page")] |
| 153 | » » public·const·int·Debug | 153 | » » public·const·int·DebugPagePrev·=·57; |
| 154 | 154 | ||
| 155 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug | 155 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug·Next·Subpage")] |
| 156 | » » public·const·int·Debug | 156 | » » public·const·int·DebugSubpageNext·=·58; |
| 157 | 157 | ||
| 158 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug | 158 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug·Previous·Subpage")] |
| 159 | » » public·const·int·Debug | 159 | » » public·const·int·DebugSubpagePrev·=·59; |
| 160 | 160 | ||
| 161 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolStart")] | ||
| 162 | » » public·const·int·DebugToolStart·=·60; | ||
| 163 | |||
| 164 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug | 161 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugNavVertical")] |
| 165 | » » public·const·int·Debug | 162 | » » public·const·int·DebugNavVertical·=·63; |
| 166 | 163 | ||
| 167 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug | 164 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugNavHorizontal")] |
| 168 | » » public·const·int·Debug | 165 | » » public·const·int·DebugNavHorizontal·=·75; |
| 169 | 166 | ||
| 170 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug | 167 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugConfirm")] |
| 171 | » » public·const·int·Debug | 168 | » » public·const·int·DebugConfirm·=·65; |
| 172 | 169 | ||
| 173 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug | 170 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugCancel")] |
| 174 | » » public·const·int·Debug | 171 | » » public·const·int·DebugCancel·=·66; |
| 175 | 172 | ||
| 176 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugTool | 173 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolStart")] |
| 177 | » » public·const·int·DebugTool | 174 | » » public·const·int·DebugToolStart·=·60; |
| 178 | 175 | ||
| 179 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolCopy")] | 176 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolCopy")] |
| 180 | » » public·const·int·DebugToolCopy·=·67; | 177 | » » public·const·int·DebugToolCopy·=·67; |
| 181 | 178 | ||
| 182 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolClear")] | 179 | » » [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolClear")] |
| 183 | » » public·const·int·DebugToolClear·=·68; | 180 | » » public·const·int·DebugToolClear·=·68; |
| 184 | 181 | ||
| Offset 12, 10 lines modified | Offset 12, 10 lines modified | ||
| 12 | 12 | ||
| 13 | » » public·const·int·Task·=·3; | 13 | » » public·const·int·Task·=·3; |
| 14 | 14 | ||
| 15 | » » public·const·int·QuickChat·=·4; | 15 | » » public·const·int·QuickChat·=·4; |
| 16 | 16 | ||
| 17 | » » public·const·int·Protected_Keyboard_Controls·=·5; | 17 | » » public·const·int·Protected_Keyboard_Controls·=·5; |
| 18 | 18 | ||
| 19 | » » public·const·int·Debug | 19 | » » public·const·int·Debug·=·6; |
| 20 | » } | 20 | » } |
| 21 | } | 21 | } |
| Offset 43, 10 lines modified | Offset 43, 36 lines modified | ||
| 43 | » » ActionQuaternary·=·49, | 43 | » » ActionQuaternary·=·49, |
| 44 | » » UseVent, | 44 | » » UseVent, |
| 45 | » » MenuLB·=·52, | 45 | » » MenuLB·=·52, |
| 46 | » » MenuRB, | 46 | » » MenuRB, |
| 47 | » » QuickChatFavorite·=·69, | 47 | » » QuickChatFavorite·=·69, |
| 48 | » » QuickChatClear, | 48 | » » QuickChatClear, |
| 49 | » » ChatSend, | 49 | » » ChatSend, |
| 50 | » » QuickChatOpen | 50 | » » QuickChatOpen, |
| 51 | » » DebugPageNext·=·56, | ||
| 52 | » » DebugPagePrev, | ||
| 53 | » » DebugSubpageNext, | ||
| 54 | » » DebugSubpagePrev, | ||
| 55 | » » DebugNavVertical·=·63, | ||
| 56 | » » DebugNavHorizontal·=·75, | ||
| 57 | » » DebugConfirm·=·65, | ||
| 58 | » » DebugCancel, | ||
| 59 | » » DebugToolStart·=·60, | ||
| 60 | » » DebugToolCopy·=·67, | ||
| 61 | » » DebugToolClear | ||
| 62 | » } | ||
| 63 | |||
| 64 | » public·enum·DebugAction | ||
| 65 | » { | ||
| 66 | » » DebugPageNext·=·56, | ||
| 67 | » » DebugPagePrev, | ||
| 68 | » » DebugSubpageNext, | ||
| 69 | » » DebugSubpagePrev, | ||
| 70 | » » DebugNavVertical·=·63, | ||
| 71 | » » DebugNavHorizontal·=·75, | ||
| 72 | » » DebugConfirm·=·65, | ||
| 73 | » » DebugCancel, | ||
| 74 | » » DebugToolStart·=·60, | ||
| 75 | » » DebugToolCopy·=·67, | ||
| 76 | » » DebugToolClear | ||
| 51 | » } | 77 | » } |
| 52 | } | 78 | } |
| Offset 254, 29 lines modified | Offset 254, 29 lines modified | ||
| 254 | » [Range(0.1f,·10f)] | 254 | » [Range(0.1f,·10f)] |
| 255 | » private·float·timeToToasted·=·5f; | 255 | » private·float·timeToToasted·=·5f; |
| 256 | 256 | ||
| 257 | » [SerializeField] | 257 | » [SerializeField] |
| 258 | » [Range(0.1f,·10f)] | 258 | » [Range(0.1f,·10f)] |
| 259 | » private·float·timeToBurnt·=·3f; | 259 | » private·float·timeToBurnt·=·3f; |
| 260 | 260 | ||
| 261 | » [SerializeField] | ||
| 262 | » [Header("Animators")] | 261 | » [Header("Animators")] |
| 262 | » [SerializeField] | ||
| 263 | » private·Animator·fireAnimator; | 263 | » private·Animator·fireAnimator; |
| 264 | 264 | ||
| 265 | » [SerializeField] | 265 | » [SerializeField] |
| 266 | » private·Animator·bagAnimator; | 266 | » private·Animator·bagAnimator; |
| 267 | 267 | ||
| 268 | » [SerializeField] | 268 | » [SerializeField] |
| 269 | » private·Animator·stickAnimator; | 269 | » private·Animator·stickAnimator; |
| 270 | 270 | ||
| 271 | » [SerializeField] | 271 | » [SerializeField] |
| 272 | » private·Animator·marshmallowAnimator; | 272 | » private·Animator·marshmallowAnimator; |
| 273 | 273 | ||
| 274 | » [SerializeField] | ||
| 275 | » [Space(10f)] | 274 | » [Space(10f)] |
| 275 | » [SerializeField] | ||
| 276 | » private·SpriteRenderer·toastedMarshmallow; | 276 | » private·SpriteRenderer·toastedMarshmallow; |
| 277 | 277 | ||
| 278 | » [SerializeField] | 278 | » [SerializeField] |
| 279 | » [Header("Buttons")] | 279 | » [Header("Buttons")] |
| 280 | » private·PassiveButton·bagMarshmallowButton; | 280 | » private·PassiveButton·bagMarshmallowButton; |
| 281 | 281 | ||
| 282 | » [SerializeField] | 282 | » [SerializeField] |
| Offset 107, 25 lines modified | Offset 107, 44 lines modified | ||
| 107 | » { | 107 | » { |
| 108 | » } | 108 | » } |
| 109 | 109 | ||
| 110 | » public·virtual·void·UseAbility() | 110 | » public·virtual·void·UseAbility() |
| 111 | » { | 111 | » { |
| 112 | » } | 112 | » } |
| 113 | 113 | ||
| 114 | » public·virtual·void·OnMeetingStart() | ||
| 115 | » { | ||
| 116 | » } | ||
| 117 | |||
| 114 | » public·virtual·void·OnVotingComplete() | 118 | » public·virtual·void·OnVotingComplete() |
| 115 | » { | 119 | » { |
| 116 | » } | 120 | » } |
| 117 | 121 | ||
| 122 | » public·virtual·void·OnDeath(DeathReason·reason) | ||
| 123 | » { | ||
| 124 | » } | ||
| 125 | |||
| 118 | » public·virtual·void·Initialize(PlayerControl·player) | 126 | » public·virtual·void·Initialize(PlayerControl·player) |
| 119 | » { | 127 | » { |
| 120 | » » this.Player·=·player; | 128 | » » this.Player·=·player; |
| 121 | » » if·(!player.AmOwner) | 129 | » » if·(!player.AmOwner) |
| 122 | » » { | 130 | » » { |
| 123 | » » » return; | 131 | » » » return; |
| 124 | » » } | 132 | » » } |
| 133 | » » if·(this.IsImpostor) | ||
| 134 | » » { | ||
| 135 | » » » if·(this.CanUseKillButton) | ||
| 136 | » » » { | ||
| 137 | » » » » DestroyableSingleton<HudManager>.Instance.KillButton.Show(); | ||
| 138 | » » » » player.SetKillTimer(10f); | ||
| 139 | » » » } | ||
| 140 | » » » DestroyableSingleton<HudManager>.Instance.SabotageButton.Show(); | ||
| 141 | » » » DestroyableSingleton<HudManager>.Instance.AdminButton.Show(); | ||
| 142 | » » » DestroyableSingleton<HudManager>.Instance.ImpostorVentButton.Show(); | ||
| 143 | » » } | ||
| 125 | » » DestroyableSingleton<HudManager>.Instance.SetHudActive(player,·this,·true); | 144 | » » DestroyableSingleton<HudManager>.Instance.SetHudActive(player,·this,·true); |
| 126 | » » PlayerNameColor.SetForRoleDirectly(player,·this); | 145 | » » PlayerNameColor.SetForRoleDirectly(player,·this); |
| 127 | » » this.InitializeAbilityButton(); | 146 | » » this.InitializeAbilityButton(); |
| 128 | » } | 147 | » } |
| 129 | 148 | ||
| 130 | » public·virtual·void·SetUsableTarget(IUsable·target) | 149 | » public·virtual·void·SetUsableTarget(IUsable·target) |
| 131 | » { | 150 | » { |
| Offset 154, 17 lines modified | Offset 173, 17 lines modified | ||
| 154 | » } | 173 | » } |
| 155 | 174 | ||
| 156 | » private·void·SetAbilityUsesRemaining(int·num) | 175 | » private·void·SetAbilityUsesRemaining(int·num) |
| 157 | » { | 176 | » { |
| 158 | » » this.buttonManager.SetUsesRemaining(num); | 177 | » » this.buttonManager.SetUsesRemaining(num); |
| 159 | » } | 178 | » } |
| 160 | 179 | ||
| 161 | » protected·virtual·bool·IsValidTarget( | 180 | » protected·virtual·bool·IsValidTarget(NetworkedPlayerInfo·target) |
| 162 | » { | 181 | » { |
| 163 | » » return·target· | 182 | » » return·!(target·==·null)·&&·!target.Disconnected·&&·!target.IsDead·&&·target.PlayerId·!=·this.Player.PlayerId·&&·!(target.Role·==·null)·&&·!(target.Object·==·null)·&&·!target.Object.inVent·&&·!target.Object.inMovingPlat·&&·target.Object.Visible; |
| 164 | » } | 183 | » } |
| 165 | 184 | ||
| 166 | » public·virtual·PlayerControl·FindClosestTarget() | 185 | » public·virtual·PlayerControl·FindClosestTarget() |
| 167 | » { | 186 | » { |
| 168 | » » return·null; | 187 | » » return·null; |
| 169 | » } | 188 | » } |
| 170 | 189 | ||
| Offset 184, 21 lines modified | Offset 203, 21 lines modified | ||
| 184 | » } | 203 | » } |
| 185 | 204 | ||
| 186 | » protected·List<PlayerControl>·GetPlayersInAbilityRangeSorted(List<PlayerControl>·outputList,·bool·ignoreColliders) | 205 | » protected·List<PlayerControl>·GetPlayersInAbilityRangeSorted(List<PlayerControl>·outputList,·bool·ignoreColliders) |
| 187 | » { | 206 | » { |
| 188 | » » outputList.Clear(); | 207 | » » outputList.Clear(); |
| 189 | » » float·abilityDistance·=·this.GetAbilityDistance(); | 208 | » » float·abilityDistance·=·this.GetAbilityDistance(); |
| 190 | » » Vector2·myPos·=·this.Player.GetTruePosition(); | 209 | » » Vector2·myPos·=·this.Player.GetTruePosition(); |
| 191 | » » List< | 210 | » » List<NetworkedPlayerInfo>·allPlayers·=·GameData.Instance.AllPlayers; |
| 192 | » » for·(int·i·=·0;·i·<·allPlayers.Count;·i++) | 211 | » » for·(int·i·=·0;·i·<·allPlayers.Count;·i++) |
| 193 | » » { | 212 | » » { |
| 194 | » » » | 213 | » » » NetworkedPlayerInfo·networkedPlayerInfo·=·allPlayers[i]; |
| 195 | » » » if·(this.IsValidTarget( | 214 | » » » if·(this.IsValidTarget(networkedPlayerInfo)) |
| 196 | » » » { | 215 | » » » { |
| 197 | » » » » PlayerControl·@object·=· | 216 | » » » » PlayerControl·@object·=·networkedPlayerInfo.Object; |
| 198 | » » » » if·(@object·&&·@object.Collider.enabled) | 217 | » » » » if·(@object·&&·@object.Collider.enabled) |
| 199 | » » » » { | 218 | » » » » { |
| 200 | » » » » » Vector2·vector·=·@object.GetTruePosition()·-·myPos; | 219 | » » » » » Vector2·vector·=·@object.GetTruePosition()·-·myPos; |
| 201 | » » » » » float·magnitude·=·vector.magnitude; | 220 | » » » » » float·magnitude·=·vector.magnitude; |
| 202 | » » » » » if·(magnitude·<=·abilityDistance·&&·(ignoreColliders·||·!PhysicsHelpers.AnyNonTriggersBetween(myPos,·vector.normalized,·magnitude,·Constants.ShipAndObjectsMask))) | 221 | » » » » » if·(magnitude·<=·abilityDistance·&&·(ignoreColliders·||·!PhysicsHelpers.AnyNonTriggersBetween(myPos,·vector.normalized,·magnitude,·Constants.ShipAndObjectsMask))) |
| 203 | » » » » » { | 222 | » » » » » { |
| 204 | » » » » » » outputList.Add(@object); | 223 | » » » » » » outputList.Add(@object); |
| Offset 238, 14 lines modified | Offset 257, 20 lines modified | ||
| 238 | 257 | ||
| 239 | » public·StringNames·BlurbName·=·StringNames.CrewmateBlurb; | 258 | » public·StringNames·BlurbName·=·StringNames.CrewmateBlurb; |
| 240 | 259 | ||
| 241 | » public·StringNames·BlurbNameMed·=·StringNames.CrewmateBlurb; | 260 | » public·StringNames·BlurbNameMed·=·StringNames.CrewmateBlurb; |
| 242 | 261 | ||
| 243 | » public·StringNames·BlurbNameLong·=·StringNames.CrewmateBlurb; | 262 | » public·StringNames·BlurbNameLong·=·StringNames.CrewmateBlurb; |
| 244 | 263 | ||
| 264 | » public·Sprite·RoleIconSolid; | ||
| 265 | |||
| 266 | » public·Sprite·RoleIconWhite; | ||
| 267 | |||
| 268 | » public·Sprite·RoleScreenshot; | ||
| 269 | |||
| 245 | » public·Color·NameColor·=·Color.white; | 270 | » public·Color·NameColor·=·Color.white; |
| 246 | 271 | ||
| 247 | » public·bool·TasksCountTowardProgress·=·true; | 272 | » public·bool·TasksCountTowardProgress·=·true; |
| 248 | 273 | ||
| 249 | » public·bool·CanUseKillButton; | 274 | » public·bool·CanUseKillButton; |
| 250 | 275 | ||
| 251 | » public·bool·CanBeKilled·=·true; | 276 | » public·bool·CanBeKilled·=·true; |
| Offset 1, 24 lines modified | Offset 1, 32 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections; | 2 | using·System.Collections; |
| 3 | using·PowerTools; | 3 | using·PowerTools; |
| 4 | using·UnityEngine; | 4 | using·UnityEngine; |
| 5 | 5 | ||
| 6 | public·class·RoleEffectAnimation·:·MonoBehaviour | 6 | public·class·RoleEffectAnimation·:·MonoBehaviour |
| 7 | { | 7 | { |
| 8 | » public·void·Play(PlayerControl·parent,·Action·onClipEnded,·bool·flipX,·RoleEffectAnimation.SoundType·soundType,·float·duration·=·0f) | 8 | » public·void·Play(PlayerControl·parent,·Action·onClipEnded,·bool·flipX,·RoleEffectAnimation.SoundType·soundType,·float·duration·=·0f,·bool·parentTransform·=·true,·float·flipXOffset·=·0f) |
| 9 | » { | 9 | » { |
| 10 | » » base.StartCoroutine(this.CoPlay(parent,·onClipEnded,·flipX,·soundType,·duration)); | 10 | » » base.StartCoroutine(this.CoPlay(parent,·onClipEnded,·flipX,·soundType,·duration,·parentTransform,·flipXOffset)); |
| 11 | » } | 11 | » } |
| 12 | 12 | ||
| 13 | » private·IEnumerator·CoPlay(PlayerControl·parent,·Action·onClipEnded,·bool·flipX,·RoleEffectAnimation.SoundType·soundType,·float·duration·=·0f) | 13 | » private·IEnumerator·CoPlay(PlayerControl·parent,·Action·onClipEnded,·bool·flipX,·RoleEffectAnimation.SoundType·soundType,·float·duration·=·0f,·bool·parentTransform·=·true,·float·flipXOffset·=·0f) |
| 14 | » { | 14 | » { |
| 15 | » » this.parent·=·parent; | 15 | » » this.parent·=·parent; |
| 16 | » » if·(!parentTransform) | ||
| 17 | » » { | ||
| 18 | » » » base.transform.parent·=·null; | ||
| 19 | » » } | ||
| 16 | » » parent.currentRoleAnimations.Add(this); | 20 | » » parent.currentRoleAnimations.Add(this); |
| 17 | » » this.Renderer.flipX·=·flipX; | 21 | » » this.Renderer.flipX·=·flipX; |
| 22 | » » if·(flipX) | ||
| 23 | » » { | ||
| 24 | » » » base.transform.position·+=·new·Vector3(flipXOffset,·0f,·0f); | ||
| 25 | » » } | ||
| 18 | » » if·(this.UseSound) | 26 | » » if·(this.UseSound) |
| 19 | » » { | 27 | » » { |
| 20 | » » » if·(soundType·!=·RoleEffectAnimation.SoundType.Local) | 28 | » » » if·(soundType·!=·RoleEffectAnimation.SoundType.Local) |
| 21 | » » » { | 29 | » » » { |
| 22 | » » » » if·(soundType·==·RoleEffectAnimation.SoundType.Global) | 30 | » » » » if·(soundType·==·RoleEffectAnimation.SoundType.Global) |
| 23 | » » » » { | 31 | » » » » { |
| 24 | » » » » » SoundManager.Instance.PlaySound(this.UseSound,·false,·1f,·null); | 32 | » » » » » SoundManager.Instance.PlaySound(this.UseSound,·false,·1f,·null); |
| Offset 109, 10 lines modified | Offset 117, 13 lines modified | ||
| 109 | » » Global | 117 | » » Global |
| 110 | » } | 118 | » } |
| 111 | 119 | ||
| 112 | » public·enum·EffectType | 120 | » public·enum·EffectType |
| 113 | » { | 121 | » { |
| 114 | » » Default, | 122 | » » Default, |
| 115 | » » ProtectLoop, | 123 | » » ProtectLoop, |
| 116 | » » Shapeshift | 124 | » » Shapeshift, |
| 125 | » » Vanish_Charge, | ||
| 126 | » » Vanish_Poof, | ||
| 127 | » » Appear_Poof | ||
| 117 | » } | 128 | » } |
| 118 | } | 129 | } |
| Offset 21, 26 lines modified | Offset 21, 26 lines modified | ||
| 21 | 21 | ||
| 22 | » public·void·SetRole(PlayerControl·targetPlayer,·RoleTypes·roleType) | 22 | » public·void·SetRole(PlayerControl·targetPlayer,·RoleTypes·roleType) |
| 23 | » { | 23 | » { |
| 24 | » » if·(!targetPlayer) | 24 | » » if·(!targetPlayer) |
| 25 | » » { | 25 | » » { |
| 26 | » » » return; | 26 | » » » return; |
| 27 | » » } | 27 | » » } |
| 28 | » » | 28 | » » NetworkedPlayerInfo·data·=·targetPlayer.Data; |
| 29 | » » if·(data·==·null) | 29 | » » if·(data·==·null) |
| 30 | » » { | 30 | » » { |
| 31 | » » » Debug.LogError("It·shouldn't·be·possible,·but·"·+·targetPlayer.name·+·"·still·doesn't·have·PlayerData·during·role·selection."); | 31 | » » » Debug.LogError("It·shouldn't·be·possible,·but·"·+·targetPlayer.name·+·"·still·doesn't·have·PlayerData·during·role·selection."); |
| 32 | » » » return; | 32 | » » » return; |
| 33 | » » } | 33 | » » } |
| 34 | » » if·(data.Role) | 34 | » » if·(data.Role) |
| 35 | » » { | 35 | » » { |
| 36 | » » » data.Role.Deinitialize(targetPlayer); | 36 | » » » data.Role.Deinitialize(targetPlayer); |
| 37 | » » » Object.Destroy(data.Role.gameObject); | 37 | » » » Object.Destroy(data.Role.gameObject); |
| 38 | » » } | 38 | » » } |
| 39 | » » RoleBehaviour·roleBehaviour·=·Object.Instantiate<RoleBehaviour>(Enumerable.First<RoleBehaviour>(this.AllRoles,·(RoleBehaviour·r)·=>·r.Role·==·roleType),· | 39 | » » RoleBehaviour·roleBehaviour·=·Object.Instantiate<RoleBehaviour>(Enumerable.First<RoleBehaviour>(this.AllRoles,·(RoleBehaviour·r)·=>·r.Role·==·roleType),·data.gameObject.transform); |
| 40 | » » roleBehaviour.Initialize(targetPlayer); | 40 | » » roleBehaviour.Initialize(targetPlayer); |
| 41 | » » targetPlayer.Data.Role·=·roleBehaviour; | 41 | » » targetPlayer.Data.Role·=·roleBehaviour; |
| 42 | » » targetPlayer.Data.RoleType·=·roleType; | 42 | » » targetPlayer.Data.RoleType·=·roleType; |
| 43 | » » if·(roleType·!=·RoleTypes.ImpostorGhost·&&·roleType·!=·RoleTypes.CrewmateGhost) | 43 | » » if·(roleType·!=·RoleTypes.ImpostorGhost·&&·roleType·!=·RoleTypes.CrewmateGhost) |
| 44 | » » { | 44 | » » { |
| 45 | » » » targetPlayer.Data.RoleWhenAlive·=·new·RoleTypes?(roleType); | 45 | » » » targetPlayer.Data.RoleWhenAlive·=·new·RoleTypes?(roleType); |
| 46 | » » } | 46 | » » } |
| Offset 56, 20 lines modified | Offset 56, 20 lines modified | ||
| 56 | » » } | 56 | » » } |
| 57 | » } | 57 | » } |
| 58 | 58 | ||
| 59 | » public·void·SelectRoles() | 59 | » public·void·SelectRoles() |
| 60 | » { | 60 | » { |
| 61 | » » List<ClientData>·list·=·new·List<ClientData>(); | 61 | » » List<ClientData>·list·=·new·List<ClientData>(); |
| 62 | » » AmongUsClient.Instance.GetAllClients(list); | 62 | » » AmongUsClient.Instance.GetAllClients(list); |
| 63 | » » List< | 63 | » » List<NetworkedPlayerInfo>·list2·=·Enumerable.ToList<NetworkedPlayerInfo>(Enumerable.Select<ClientData,·NetworkedPlayerInfo>(Enumerable.OrderBy<ClientData,·int>(Enumerable.Where<ClientData>(Enumerable.Where<ClientData>(Enumerable.Where<ClientData>(list,·(ClientData·c)·=>·c.Character·!=·null),·(ClientData·c)·=>·c.Character.Data·!=·null),·(ClientData·c)·=>·!c.Character.Data.Disconnected·&&·!c.Character.Data.IsDead),·(ClientData·c)·=>·c.Id),·(ClientData·c)·=>·c.Character.Data)); |
| 64 | » » foreach·( | 64 | » » foreach·(NetworkedPlayerInfo·networkedPlayerInfo·in·GameData.Instance.AllPlayers) |
| 65 | » » { | 65 | » » { |
| 66 | » » » if·( | 66 | » » » if·(networkedPlayerInfo.Object·!=·null·&&·networkedPlayerInfo.Object.isDummy) |
| 67 | » » » { | 67 | » » » { |
| 68 | » » » » list2.Add( | 68 | » » » » list2.Add(networkedPlayerInfo); |
| 69 | » » » } | 69 | » » » } |
| 70 | » » } | 70 | » » } |
| 71 | » » IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions; | 71 | » » IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions; |
| 72 | » » int·adjustedNumImpostors·=·GameOptionsManager.Instance.CurrentGameOptions.GetAdjustedNumImpostors(list2.Count); | 72 | » » int·adjustedNumImpostors·=·GameOptionsManager.Instance.CurrentGameOptions.GetAdjustedNumImpostors(list2.Count); |
| 73 | » » this.DebugRoleAssignments(list2,·ref·adjustedNumImpostors); | 73 | » » this.DebugRoleAssignments(list2,·ref·adjustedNumImpostors); |
| 74 | » » GameManager.Instance.LogicRoleSelection.AssignRolesForTeam(list2,·currentGameOptions,·RoleTeamTypes.Impostor,·adjustedNumImpostors,·new·RoleTypes?(RoleTypes.Impostor)); | 74 | » » GameManager.Instance.LogicRoleSelection.AssignRolesForTeam(list2,·currentGameOptions,·RoleTeamTypes.Impostor,·adjustedNumImpostors,·new·RoleTypes?(RoleTypes.Impostor)); |
| 75 | » » GameManager.Instance.LogicRoleSelection.AssignRolesForTeam(list2,·currentGameOptions,·RoleTeamTypes.Crewmate,·int.MaxValue,·new·RoleTypes?(RoleTypes.Crewmate)); | 75 | » » GameManager.Instance.LogicRoleSelection.AssignRolesForTeam(list2,·currentGameOptions,·RoleTeamTypes.Crewmate,·int.MaxValue,·new·RoleTypes?(RoleTypes.Crewmate)); |
| Offset 83, 40 lines modified | Offset 83, 40 lines modified | ||
| 83 | » » } | 83 | » » } |
| 84 | » » if·(!player.Data.Role.IsImpostor·&&·specialRolesAllowed) | 84 | » » if·(!player.Data.Role.IsImpostor·&&·specialRolesAllowed) |
| 85 | » » { | 85 | » » { |
| 86 | » » » RoleManager.TryAssignSpecialGhostRoles(player); | 86 | » » » RoleManager.TryAssignSpecialGhostRoles(player); |
| 87 | » » } | 87 | » » } |
| 88 | » » if·(!RoleManager.IsGhostRole(player.Data.Role.Role)) | 88 | » » if·(!RoleManager.IsGhostRole(player.Data.Role.Role)) |
| 89 | » » { | 89 | » » { |
| 90 | » » » player.RpcSetRole(player.Data.Role.DefaultGhostRole); | 90 | » » » player.RpcSetRole(player.Data.Role.DefaultGhostRole,·false); |
| 91 | » » } | 91 | » » } |
| 92 | » } | 92 | » } |
| 93 | 93 | ||
| 94 | » private·void·DebugRoleAssignments(List< | 94 | » private·void·DebugRoleAssignments(List<NetworkedPlayerInfo>·players,·ref·int·numImpostors) |
| 95 | » { | 95 | » { |
| 96 | » } | 96 | » } |
| 97 | 97 | ||
| 98 | » private·static·void·TryAssignSpecialGhostRoles(PlayerControl·player) | 98 | » private·static·void·TryAssignSpecialGhostRoles(PlayerControl·player) |
| 99 | » { | 99 | » { |
| 100 | » » RoleTypes·roleTypes·=·RoleTypes.GuardianAngel; | 100 | » » RoleTypes·roleTypes·=·RoleTypes.GuardianAngel; |
| 101 | » » int·num·=·Enumerable.Count<PlayerControl>(PlayerControl.AllPlayerControls,·(PlayerControl·pc)·=>·pc.Data.IsDead·&&·!pc.Data.Role.IsImpostor); | 101 | » » int·num·=·Enumerable.Count<PlayerControl>(PlayerControl.AllPlayerControls,·(PlayerControl·pc)·=>·pc.Data.IsDead·&&·!pc.Data.Role.IsImpostor); |
| 102 | » » IRoleOptionsCollection·roleOptions·=·GameOptionsManager.Instance.CurrentGameOptions.RoleOptions; | 102 | » » IRoleOptionsCollection·roleOptions·=·GameOptionsManager.Instance.CurrentGameOptions.RoleOptions; |
| 103 | » » if·(AmongUsClient.Instance.NetworkMode·==·NetworkModes.FreePlay) | 103 | » » if·(AmongUsClient.Instance.NetworkMode·==·NetworkModes.FreePlay) |
| 104 | » » { | 104 | » » { |
| 105 | » » » player.RpcSetRole(roleTypes); | 105 | » » » player.RpcSetRole(roleTypes,·false); |
| 106 | » » » return; | 106 | » » » return; |
| 107 | » » } | 107 | » » } |
| 108 | » » if·(num·>·roleOptions.GetNumPerGame(roleTypes)) | 108 | » » if·(num·>·roleOptions.GetNumPerGame(roleTypes)) |
| 109 | » » { | 109 | » » { |
| 110 | » » » return; | 110 | » » » return; |
| 111 | » » } | 111 | » » } |
| 112 | » » int·chancePerGame·=·roleOptions.GetChancePerGame(roleTypes); | 112 | » » int·chancePerGame·=·roleOptions.GetChancePerGame(roleTypes); |
| 113 | » » if·(HashRandom.Next(101)·<·chancePerGame) | 113 | » » if·(HashRandom.Next(101)·<·chancePerGame) |
| 114 | » » { | 114 | » » { |
| 115 | » » » player.RpcSetRole(roleTypes); | 115 | » » » player.RpcSetRole(roleTypes,·false); |
| 116 | » » } | 116 | » » } |
| 117 | » } | 117 | » } |
| 118 | 118 | ||
| 119 | » public·static·bool·IsGhostRole(RoleTypes·role) | 119 | » public·static·bool·IsGhostRole(RoleTypes·role) |
| 120 | » { | 120 | » { |
| 121 | » » return·RoleManager.GhostRoles.Contains(role); | 121 | » » return·RoleManager.GhostRoles.Contains(role); |
| 122 | » } | 122 | » } |
| Offset 143, 14 lines modified | Offset 143, 20 lines modified | ||
| 143 | 143 | ||
| 144 | » public·RoleEffectAnimation·shapeshiftAnim; | 144 | » public·RoleEffectAnimation·shapeshiftAnim; |
| 145 | 145 | ||
| 146 | » public·RoleEffectAnimation·protectAnim; | 146 | » public·RoleEffectAnimation·protectAnim; |
| 147 | 147 | ||
| 148 | » public·RoleEffectAnimation·protectLoopAnim; | 148 | » public·RoleEffectAnimation·protectLoopAnim; |
| 149 | 149 | ||
| 150 | » public·RoleEffectAnimation·vanish_ChargeAnim; | ||
| 151 | |||
| 152 | » public·RoleEffectAnimation·vanish_PoofAnim; | ||
| 153 | |||
| 154 | » public·RoleEffectAnimation·appear_PoofAnim; | ||
| 155 | |||
| 150 | » public·class·RoleAssignmentData | 156 | » public·class·RoleAssignmentData |
| 151 | » { | 157 | » { |
| 152 | » » public·RoleAssignmentData(RoleBehaviour·role,·int·count,·int·chance) | 158 | » » public·RoleAssignmentData(RoleBehaviour·role,·int·count,·int·chance) |
| 153 | » » { | 159 | » » { |
| 154 | » » » this.Role·=·role; | 160 | » » » this.Role·=·role; |
| 155 | » » » this.Count·=·count; | 161 | » » » this.Count·=·count; |
| 156 | » » » this.Chance·=·chance; | 162 | » » » this.Chance·=·chance; |
| Offset 1, 98 lines modified | Offset 1, 216 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections.Generic; | ||
| 2 | using·AmongUs.GameOptions; | 3 | using·AmongUs.GameOptions; |
| 3 | using·TMPro; | 4 | using·TMPro; |
| 4 | using·UnityEngine; | 5 | using·UnityEngine; |
| 5 | 6 | ||
| 6 | public·class·RoleOptionSetting·:·OptionBehaviour | 7 | public·class·RoleOptionSetting·:·OptionBehaviour |
| 7 | { | 8 | { |
| 9 | » public·int·RoleMaxCount | ||
| 10 | » { | ||
| 11 | » » get | ||
| 12 | » » { | ||
| 13 | » » » return·this.roleMaxCount; | ||
| 14 | » » } | ||
| 15 | » } | ||
| 16 | |||
| 17 | » public·int·RoleChance | ||
| 18 | » { | ||
| 19 | » » get | ||
| 20 | » » { | ||
| 21 | » » » return·this.roleChance; | ||
| 22 | » » } | ||
| 23 | » } | ||
| 24 | |||
| 25 | » public·RoleBehaviour·Role | ||
| 26 | » { | ||
| 27 | » » get | ||
| 28 | » » { | ||
| 29 | » » » return·this.role; | ||
| 30 | » » } | ||
| 31 | » } | ||
| 32 | |||
| 33 | » public·List<PassiveButton>·ControllerSelectable | ||
| 34 | » { | ||
| 35 | » » get | ||
| 36 | » » { | ||
| 37 | » » » return·this.controllerSelectable; | ||
| 38 | » » } | ||
| 39 | » } | ||
| 40 | |||
| 8 | » private·int·RoleMax | 41 | » private·int·RoleMax |
| 9 | » { | 42 | » { |
| 10 | » » get | 43 | » » get |
| 11 | » » { | 44 | » » { |
| 12 | » » » return·Mathf.Min(this. | 45 | » » » return·Mathf.Min(this.role.MaxCount,·15); |
| 13 | » » } | 46 | » » } |
| 14 | » } | 47 | » } |
| 15 | 48 | ||
| 16 | » public·void·SetRole(IRoleOptionsCollection·options) | 49 | » public·void·SetRole(IRoleOptionsCollection·options,·RoleBehaviour·role,·int·maskLayer) |
| 17 | » { | 50 | » { |
| 51 | » » SpriteRenderer[]·componentsInChildren·=·base.GetComponentsInChildren<SpriteRenderer>(true); | ||
| 52 | » » for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++) | ||
| 53 | » » { | ||
| 54 | » » » componentsInChildren[i].material.SetInt(PlayerMaterial.MaskLayer,·maskLayer); | ||
| 55 | » » } | ||
| 56 | » » foreach·(TextMeshPro·textMeshPro·in·base.GetComponentsInChildren<TextMeshPro>(true)) | ||
| 57 | » » { | ||
| 58 | » » » textMeshPro.fontMaterial.SetFloat("_StencilComp",·3f); | ||
| 59 | » » » textMeshPro.fontMaterial.SetFloat("_Stencil",·(float)maskLayer); | ||
| 60 | » » } | ||
| 61 | » » this.role·=·role; | ||
| 18 | » » this. | 62 | » » this.titleText.text·=·this.role.NiceName; |
| 63 | » » if·(role.TeamType·==·RoleTeamTypes.Crewmate) | ||
| 64 | » » { | ||
| 65 | » » » this.labelSprite.color·=·Palette.CrewmateRoleBlue; | ||
| 66 | » » } | ||
| 67 | » » else | ||
| 68 | » » { | ||
| 69 | » » » this.labelSprite.color·=·Palette.ImpostorRoleRed; | ||
| 70 | » » } | ||
| 19 | » » this.UpdateValuesAndText(options); | 71 | » » this.UpdateValuesAndText(options); |
| 72 | » » this.AdjustCountButtonsActiveState(); | ||
| 73 | » » this.AdjustChanceButtonsActiveState(); | ||
| 20 | » } | 74 | » } |
| 21 | 75 | ||
| 22 | » public·void·UpdateValuesAndText(IRoleOptionsCollection·options) | 76 | » public·void·UpdateValuesAndText(IRoleOptionsCollection·options) |
| 23 | » { | 77 | » { |
| 24 | » » this. | 78 | » » this.roleMaxCount·=·options.GetNumPerGame(this.role.Role); |
| 25 | » » this. | 79 | » » this.roleChance·=·options.GetChancePerGame(this.role.Role); |
| 26 | » » this. | 80 | » » this.countText.text·=·this.roleMaxCount.ToString(); |
| 27 | » » this. | 81 | » » this.chanceText.text·=·this.roleChance.ToString(); |
| 28 | » } | 82 | » } |
| 29 | 83 | ||
| 30 | » public·void·IncreaseCount() | 84 | » public·void·IncreaseCount() |
| 31 | » { | 85 | » { |
| 86 | » » if·(this.roleMaxCount·>=·this.role.MaxCount) | ||
| 87 | » » { | ||
| 88 | » » » return; | ||
| 89 | » » } | ||
| 32 | » » if·(this. | 90 | » » if·(this.roleMaxCount·==·0) |
| 33 | » » { | 91 | » » { |
| 34 | » » » this. | 92 | » » » this.roleChance·=·50; |
| 93 | » » » this.AdjustChanceButtonsActiveState(); | ||
| 35 | » » } | 94 | » » } |
| 36 | » » this. | 95 | » » this.roleMaxCount·=·Mathf.Clamp(this.roleMaxCount·+·1,·0,·this.RoleMax); |
| 37 | » » this.OnValueChanged(this); | 96 | » » this.OnValueChanged(this); |
| 38 | » » this. | 97 | » » this.AdjustCountButtonsActiveState(); |
| 39 | » } | 98 | » } |
| 40 | 99 | ||
| 41 | » public·void·DecreaseCount() | 100 | » public·void·DecreaseCount() |
| 42 | » { | 101 | » { |
| 43 | » » this.RoleMaxCount·=·Mathf.Clamp(this.RoleMaxCount·-·1,·0,·this.RoleMax); | ||
| 44 | » » if·(this. | 102 | » » if·(this.roleMaxCount·==·0) |
| 45 | » » { | 103 | » » { |
| 104 | » » » return; | ||
| 105 | » » } | ||
| 106 | » » this.roleMaxCount·=·Mathf.Clamp(this.roleMaxCount·-·1,·0,·this.RoleMax); | ||
| 107 | » » if·(this.roleMaxCount·==·0) | ||
| 108 | » » { | ||
| 46 | » » » this. | 109 | » » » this.roleChance·=·0; |
| 110 | » » » this.AdjustChanceButtonsActiveState(); | ||
| 47 | » » } | 111 | » » } |
| 48 | » » this.OnValueChanged(this); | 112 | » » this.OnValueChanged(this); |
| 49 | » » this. | 113 | » » this.AdjustCountButtonsActiveState(); |
| 50 | » } | 114 | » } |
| 51 | 115 | ||
| 52 | » public·void·IncreaseChance() | 116 | » public·void·IncreaseChance() |
| 53 | » { | 117 | » { |
| 118 | » » if·(this.roleChance·>=·100) | ||
| 119 | » » { | ||
| 120 | » » » return; | ||
| 121 | » » } | ||
| 54 | » » if·(this. | 122 | » » if·(this.roleChance·==·0) |
| 55 | » » { | 123 | » » { |
| 56 | » » » this. | 124 | » » » this.roleMaxCount·=·1; |
| 125 | » » » this.AdjustCountButtonsActiveState(); | ||
| 57 | » » } | 126 | » » } |
| Max diff block lines reached; 2728/6593 bytes (41.38%) of diff not shown. | |||
| Offset 1, 187 lines modified | Offset 1, 537 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·System.Collections.Generic; | 2 | using·System.Collections.Generic; |
| 3 | using·AmongUs.GameOptions; | 3 | using·AmongUs.GameOptions; |
| 4 | using·Rewired; | ||
| 5 | using·TMPro; | ||
| 4 | using·UnityEngine; | 6 | using·UnityEngine; |
| 5 | 7 | ||
| 6 | public·class·RolesSettingsMenu·:·MonoBehaviour | 8 | public·class·RolesSettingsMenu·:·MonoBehaviour |
| 7 | { | 9 | { |
| 8 | » private·void· | 10 | » private·void·Awake() |
| 9 | » { | 11 | » { |
| 10 | » » this.Children·=·base.GetComponentsInChildren<OptionBehaviour>(true); | ||
| 11 | » » this. | 12 | » » this.MaskBg.material.SetInt(PlayerMaterial.MaskLayer,·20); |
| 13 | » » this.MaskArea.material.SetInt(PlayerMaterial.MaskLayer,·20); | ||
| 14 | » » this.quotaHeader.SetHeader(StringNames.RoleQuotaLabel,·20); | ||
| 15 | » » this.advHeader.SetHeader(StringNames.RoleSettingsLabel,·20); | ||
| 16 | » } | ||
| 17 | |||
| 18 | » private·void·InitialSetup() | ||
| 19 | » { | ||
| 20 | » » this.QuotaTabSelectables·=·new·List<UiElement>(); | ||
| 21 | » » this.advancedSettingChildren·=·new·List<OptionBehaviour>(); | ||
| 22 | » » this.roleChances·=·new·List<RoleOptionSetting>(); | ||
| 23 | » » this.SetQuotaTab(); | ||
| 24 | » } | ||
| 25 | |||
| 26 | » private·void·OnEnable() | ||
| 27 | » { | ||
| 28 | » » this.RoleChancesSettings.SetActive(true); | ||
| 29 | » » this.AdvancedRolesSettings.SetActive(false); | ||
| 30 | » » this.RefreshChildren(); | ||
| 31 | » » SpriteRenderer[]·componentsInChildren·=·this.AdvancedRolesSettings.GetComponentsInChildren<SpriteRenderer>(true); | ||
| 12 | » » for·(int·i·=·0;·i·<· | 32 | » » for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++) |
| 13 | » » { | 33 | » » { |
| 34 | » » » componentsInChildren[i].material.SetInt(PlayerMaterial.MaskLayer,·20); | ||
| 14 | » » » OptionBehaviour·optionBehaviour·=·this.Children[i]; | ||
| 15 | » » » optionBehaviour.OnValueChanged·=·new·Action<OptionBehaviour>(this.ValueChanged); | ||
| 16 | » » » if·(AmongUsClient.Instance·&&·!AmongUsClient.Instance.AmHost) | ||
| 17 | » » » { | ||
| 18 | » » » » optionBehaviour.SetAsPlayer(); | ||
| 19 | » » | 35 | » » } |
| 36 | » » foreach·(TextMeshPro·textMeshPro·in·this.AdvancedRolesSettings.GetComponentsInChildren<TextMeshPro>(true)) | ||
| 37 | » » { | ||
| 38 | » » » textMeshPro.fontMaterial.SetFloat("_StencilComp",·3f); | ||
| 39 | » » » textMeshPro.fontMaterial.SetFloat("_Stencil",·20f); | ||
| 20 | » » } | 40 | » » } |
| 21 | » } | 41 | » } |
| 22 | 42 | ||
| 43 | » private·void·OnDisable() | ||
| 44 | » { | ||
| 45 | » » this.CloseMenu(); | ||
| 46 | » } | ||
| 47 | |||
| 48 | » public·void·OpenMenu() | ||
| 49 | » { | ||
| 50 | » » ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton,·this.DefaultButtonSelected,·this.ControllerSelectable,·false); | ||
| 51 | » » this.EnableTabControllerGlyphs(true); | ||
| 52 | » » this.OpenChancesTab(); | ||
| 53 | » } | ||
| 54 | |||
| 55 | » public·void·CloseMenu() | ||
| 56 | » { | ||
| 57 | » » ControllerManager.Instance.CloseOverlayMenu(base.name); | ||
| 58 | » » this.EnableTabControllerGlyphs(false); | ||
| 59 | » } | ||
| 60 | |||
| 23 | » private·void·Update() | 61 | » private·void·Update() |
| 24 | » { | 62 | » { |
| 25 | » » if·(this.cachedData·!=·GameOptionsManager.Instance.CurrentGameOptions.RoleOptions) | 63 | » » if·(this.cachedData·!=·GameOptionsManager.Instance.CurrentGameOptions.RoleOptions) |
| 26 | » » { | 64 | » » { |
| 27 | » » » this.cachedData·=·GameOptionsManager.Instance.CurrentGameOptions.RoleOptions; | 65 | » » » this.cachedData·=·GameOptionsManager.Instance.CurrentGameOptions.RoleOptions; |
| 28 | » » » this.RefreshChildren(); | 66 | » » » this.RefreshChildren(); |
| 29 | » » } | 67 | » » } |
| 68 | » » if·(ControllerManager.Instance.CurrentUiState.MenuName·==·base.name) | ||
| 69 | » » { | ||
| 70 | » » » Player·player·=·ReInput.players.GetPlayer(0); | ||
| 71 | » » » bool·flag·=·false; | ||
| 72 | » » » if·(this.selectedRoleTab·>·0·&&·player.GetButtonDown(35)) | ||
| 73 | » » » { | ||
| 74 | » » » » this.selectedRoleTab--; | ||
| 75 | » » » » flag·=·true; | ||
| 76 | » » » } | ||
| 77 | » » » if·(this.selectedRoleTab·<·this.roleTabs.Count·-·1·&&·player.GetButtonDown(34)) | ||
| 78 | » » » { | ||
| 79 | » » » » this.selectedRoleTab++; | ||
| 80 | » » » » flag·=·true; | ||
| 81 | » » » } | ||
| 82 | » » » if·(flag) | ||
| 83 | » » » { | ||
| 84 | » » » » if·(this.selectedRoleTab·==·0) | ||
| 85 | » » » » { | ||
| 86 | » » » » » this.OpenChancesTab(); | ||
| 87 | » » » » } | ||
| 88 | » » » » else | ||
| 89 | » » » » { | ||
| 90 | » » » » » this.roleTabs[this.selectedRoleTab].OnClick.Invoke(); | ||
| 91 | » » » » } | ||
| 92 | » » » } | ||
| 93 | » » » if·(this.selectedRoleTab·>·0) | ||
| 94 | » » » { | ||
| 95 | » » » » this.glyphL.color·=·Color.white; | ||
| 96 | » » » } | ||
| 97 | » » » else | ||
| 98 | » » » { | ||
| 99 | » » » » this.glyphL.color·=·this.glyphUnavailableColor; | ||
| 100 | » » » } | ||
| 101 | » » » if·(this.selectedRoleTab·<·this.roleTabs.Count·-·1) | ||
| 102 | » » » { | ||
| 103 | » » » » this.glyphR.color·=·Color.white; | ||
| 104 | » » » » return; | ||
| 105 | » » » } | ||
| 106 | » » » this.glyphR.color·=·this.glyphUnavailableColor; | ||
| 107 | » » } | ||
| 30 | » } | 108 | » } |
| 31 | 109 | ||
| 32 | » private·void· | 110 | » private·void·AddRoleTab(RoleRulesCategory·cat,·ref·float·tabXPos) |
| 111 | » { | ||
| 112 | » » RoleSettingsTabButton·tab; | ||
| 113 | » » if·(cat.Role.TeamType·==·RoleTeamTypes.Crewmate) | ||
| 114 | » » { | ||
| 115 | » » » tab·=·Object.Instantiate<RoleSettingsTabButton>(this.roleSettingsTabButtonOrigin,·Vector3.zero,·Quaternion.identity,·this.tabParent); | ||
| 116 | » » } | ||
| 117 | » » else | ||
| 118 | » » { | ||
| 119 | » » » tab·=·Object.Instantiate<RoleSettingsTabButton>(this.roleSettingsTabButtonOriginImpostor,·Vector3.zero,·Quaternion.identity,·this.tabParent); | ||
| 120 | » » } | ||
| 121 | » » tab.transform.localPosition·=·new·Vector3(tabXPos,·2.27f,·-2f); | ||
| Max diff block lines reached; 18565/24696 bytes (75.17%) of diff not shown. | |||
| Offset 33, 10 lines modified | Offset 33, 22 lines modified | ||
| 33 | » » { | 33 | » » { |
| 34 | » » » RoleTypes.CrewmateGhost, | 34 | » » » RoleTypes.CrewmateGhost, |
| 35 | » » » StringNames.CrewmateGhostRole | 35 | » » » StringNames.CrewmateGhostRole |
| 36 | » » }, | 36 | » » }, |
| 37 | » » { | 37 | » » { |
| 38 | » » » RoleTypes.ImpostorGhost, | 38 | » » » RoleTypes.ImpostorGhost, |
| 39 | » » » StringNames.ImpostorGhostRole | 39 | » » » StringNames.ImpostorGhostRole |
| 40 | » » }, | ||
| 41 | » » { | ||
| 42 | » » » RoleTypes.Noisemaker, | ||
| 43 | » » » StringNames.NoisemakerRole | ||
| 44 | » » }, | ||
| 45 | » » { | ||
| 46 | » » » RoleTypes.Phantom, | ||
| 47 | » » » StringNames.PhantomRole | ||
| 48 | » » }, | ||
| 49 | » » { | ||
| 50 | » » » RoleTypes.Tracker, | ||
| 51 | » » » StringNames.TrackerRole | ||
| 40 | » » } | 52 | » » } |
| 41 | » }; | 53 | » }; |
| 42 | } | 54 | } |
| Offset 54, 9 lines modified | Offset 54, 13 lines modified | ||
| 54 | » CheckZipline, | 54 | » CheckZipline, |
| 55 | » UseZipline, | 55 | » UseZipline, |
| 56 | » TriggerSpores, | 56 | » TriggerSpores, |
| 57 | » CheckSpore, | 57 | » CheckSpore, |
| 58 | » CheckShapeshift, | 58 | » CheckShapeshift, |
| 59 | » RejectShapeshift, | 59 | » RejectShapeshift, |
| 60 | » LobbyTimeExpiring·=·60, | 60 | » LobbyTimeExpiring·=·60, |
| 61 | » ExtendLobbyTimer | 61 | » ExtendLobbyTimer, |
| 62 | » CheckVanish, | ||
| 63 | » StartVanish, | ||
| 64 | » CheckAppear, | ||
| 65 | » StartAppear | ||
| 62 | } | 66 | } |
| Offset 11, 15 lines modified | Offset 11, 15 lines modified | ||
| 11 | » » » » Mode·=·MapOptions.Modes.Sabotage | 11 | » » » » Mode·=·MapOptions.Modes.Sabotage |
| 12 | » » » }); | 12 | » » » }); |
| 13 | » » } | 13 | » » } |
| 14 | » } | 14 | » } |
| 15 | 15 | ||
| 16 | » public·void·Refresh() | 16 | » public·void·Refresh() |
| 17 | » { | 17 | » { |
| 18 | » » if·(GameManager.Instance·==·null) | 18 | » » if·(GameManager.Instance·==·null·||·PlayerControl.LocalPlayer·==·null) |
| 19 | » » { | 19 | » » { |
| 20 | » » » base.ToggleVisible(false); | 20 | » » » base.ToggleVisible(false); |
| 21 | » » » base.SetDisabled(); | 21 | » » » base.SetDisabled(); |
| 22 | » » » return; | 22 | » » » return; |
| 23 | » » } | 23 | » » } |
| 24 | » » if·(PlayerControl.LocalPlayer.inVent·||·!GameManager.Instance.SabotagesEnabled()·||·PlayerControl.LocalPlayer.petting) | 24 | » » if·(PlayerControl.LocalPlayer.inVent·||·!GameManager.Instance.SabotagesEnabled()·||·PlayerControl.LocalPlayer.petting) |
| 25 | » » { | 25 | » » { |
| Offset 72, 14 lines modified | Offset 72, 15 lines modified | ||
| 72 | » » { | 72 | » » { |
| 73 | » » » for·(int·j·=·0;·j·<·this.Tubes.Length;·j++) | 73 | » » » for·(int·j·=·0;·j·<·this.Tubes.Length;·j++) |
| 74 | » » » { | 74 | » » » { |
| 75 | » » » » this.Tubes[j].color·=·Color.blue; | 75 | » » » » this.Tubes[j].color·=·Color.blue; |
| 76 | » » » } | 76 | » » » } |
| 77 | » » » this.Tubes[this.AnomalyId].color·=·Color.red; | 77 | » » » this.Tubes[this.AnomalyId].color·=·Color.red; |
| 78 | » » » this.LowerText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SamplesSelect,·Array.Empty<object>()); | 78 | » » » this.LowerText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SamplesSelect,·Array.Empty<object>()); |
| 79 | » » » this.phase1_controllerGlyph.SetActive(false); | ||
| 79 | » » » this.SetPlatformTop(); | 80 | » » » this.SetPlatformTop(); |
| 80 | » » } | 81 | » » } |
| 81 | » » base.SetupInput(true,·false); | 82 | » » base.SetupInput(true,·false); |
| 82 | » } | 83 | » } |
| 83 | 84 | ||
| 84 | » private·void·SetPlatformBottom() | 85 | » private·void·SetPlatformBottom() |
| 85 | » { | 86 | » { |
| Offset 169, 14 lines modified | Offset 170, 15 lines modified | ||
| 169 | 170 | ||
| 170 | » public·void·FixedUpdate() | 171 | » public·void·FixedUpdate() |
| 171 | » { | 172 | » { |
| 172 | » » if·(this.State·==·SampleMinigame.States.Processing) | 173 | » » if·(this.State·==·SampleMinigame.States.Processing) |
| 173 | » » { | 174 | » » { |
| 174 | » » » if·(this.MyNormTask.TaskTimer·<=·0f) | 175 | » » » if·(this.MyNormTask.TaskTimer·<=·0f) |
| 175 | » » » { | 176 | » » » { |
| 177 | » » » » this.phase1_controllerGlyph.SetActive(false); | ||
| 176 | » » » » this.State·=·SampleMinigame.States.Selection; | 178 | » » » » this.State·=·SampleMinigame.States.Selection; |
| 177 | » » » » this.LowerText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SamplesSelect,·Array.Empty<object>()); | 179 | » » » » this.LowerText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SamplesSelect,·Array.Empty<object>()); |
| 178 | » » » » this.UpperText.text·=·""; | 180 | » » » » this.UpperText.text·=·""; |
| 179 | » » » » this.AnomalyId·=·this.Tubes.RandomIdx<SpriteRenderer>(); | 181 | » » » » this.AnomalyId·=·this.Tubes.RandomIdx<SpriteRenderer>(); |
| 180 | » » » » this.Tubes[this.AnomalyId].color·=·Color.red; | 182 | » » » » this.Tubes[this.AnomalyId].color·=·Color.red; |
| 181 | » » » » SpriteRenderer[]·array·=·this.LowerButtons; | 183 | » » » » SpriteRenderer[]·array·=·this.LowerButtons; |
| 182 | » » » » for·(int·i·=·0;·i·<·array.Length;·i++) | 184 | » » » » for·(int·i·=·0;·i·<·array.Length;·i++) |
| Offset 228, 14 lines modified | Offset 230, 15 lines modified | ||
| 228 | » » » pos.y·=·this.platformY.Lerp(i·/·0.75f); | 230 | » » » pos.y·=·this.platformY.Lerp(i·/·0.75f); |
| 229 | » » » this.CenterPanel.transform.localPosition·=·pos; | 231 | » » » this.CenterPanel.transform.localPosition·=·pos; |
| 230 | » » » yield·return·wait; | 232 | » » » yield·return·wait; |
| 231 | » » } | 233 | » » } |
| 232 | » » if·(isBeginning) | 234 | » » if·(isBeginning) |
| 233 | » » { | 235 | » » { |
| 234 | » » » this.State·=·SampleMinigame.States.AwaitingStart; | 236 | » » » this.State·=·SampleMinigame.States.AwaitingStart; |
| 237 | » » » this.phase1_controllerGlyph.SetActive(true); | ||
| 235 | » » » this.LowerText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SamplesPress,·Array.Empty<object>()).PadRight(19,·'·')·+·"·-->"; | 238 | » » » this.LowerText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SamplesPress,·Array.Empty<object>()).PadRight(19,·'·')·+·"·-->"; |
| 236 | » » } | 239 | » » } |
| 237 | » » pos.y·=·this.platformY.max; | 240 | » » pos.y·=·this.platformY.max; |
| 238 | » » this.CenterPanel.transform.localPosition·=·pos; | 241 | » » this.CenterPanel.transform.localPosition·=·pos; |
| 239 | » » yield·break; | 242 | » » yield·break; |
| 240 | » } | 243 | » } |
| 241 | 244 | ||
| Offset 461, 14 lines modified | Offset 464, 17 lines modified | ||
| 461 | 464 | ||
| 462 | » private·RandomFill<AudioClip>·dropSounds; | 465 | » private·RandomFill<AudioClip>·dropSounds; |
| 463 | 466 | ||
| 464 | » public·Transform·whichButtonSelector; | 467 | » public·Transform·whichButtonSelector; |
| 465 | 468 | ||
| 466 | » public·int·whichButtonSelected·=·2; | 469 | » public·int·whichButtonSelected·=·2; |
| 467 | 470 | ||
| 471 | » [SerializeField] | ||
| 472 | » private·GameObject·phase1_controllerGlyph; | ||
| 473 | |||
| 468 | » private·float·selectMoveCooldown; | 474 | » private·float·selectMoveCooldown; |
| 469 | 475 | ||
| 470 | » public·enum·States·:·byte | 476 | » public·enum·States·:·byte |
| 471 | » { | 477 | » { |
| 472 | » » PrepareSample, | 478 | » » PrepareSample, |
| 473 | » » Complete·=·16, | 479 | » » Complete·=·16, |
| 474 | » » AwaitingStart·=·32, | 480 | » » AwaitingStart·=·32, |
| Offset 1, 9 lines modified | Offset 1, 8 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·AmongUs.Data; | ||
| 3 | using·UnityEngine; | 2 | using·UnityEngine; |
| 4 | using·UnityEngine.SceneManagement; | 3 | using·UnityEngine.SceneManagement; |
| 5 | using·UnityEngine.UI; | 4 | using·UnityEngine.UI; |
| 6 | 5 | ||
| 7 | public·class·SceneChanger·:·MonoBehaviour | 6 | public·class·SceneChanger·:·MonoBehaviour |
| 8 | { | 7 | { |
| 9 | » public·void·Click() | 8 | » public·void·Click() |
| Offset 64, 20 lines modified | Offset 63, 14 lines modified | ||
| 64 | » private·bool·AllowSceneChange() | 63 | » private·bool·AllowSceneChange() |
| 65 | » { | 64 | » { |
| 66 | » » return·this.CheckHowToPlay(); | 65 | » » return·this.CheckHowToPlay(); |
| 67 | » } | 66 | » } |
| 68 | 67 | ||
| 69 | » private·bool·CheckHowToPlay() | 68 | » private·bool·CheckHowToPlay() |
| 70 | » { | 69 | » { |
| 71 | » » if·(!DataManager.Player.Onboarding.ViewedHideAndSeekHowToPlay) | ||
| 72 | » » { | ||
| 73 | » » » HowToPlayScene.SceneOnClose·=·this.TargetScene; | ||
| 74 | » » » SceneManager.LoadScene("HowToPlay"); | ||
| 75 | » » » return·false; | ||
| 76 | » » } | ||
| 77 | » » return·true; | 70 | » » return·true; |
| 78 | » } | 71 | » } |
| 79 | 72 | ||
| 80 | » public·string·TargetScene; | 73 | » public·string·TargetScene; |
| 81 | 74 | ||
| 82 | » public·bool·disallowBasedOnSwitchParentalControls; | 75 | » public·bool·disallowBasedOnSwitchParentalControls; |
| 83 | 76 | ||
| Offset 115, 15 lines modified | Offset 115, 15 lines modified | ||
| 115 | » » this.minigame.transform.localPosition·=·new·Vector3(0f,·0f,·-50f); | 115 | » » this.minigame.transform.localPosition·=·new·Vector3(0f,·0f,·-50f); |
| 116 | » » this.minigame.BatteryText.gameObject.SetActive(true); | 116 | » » this.minigame.BatteryText.gameObject.SetActive(true); |
| 117 | » » this.minigame.Begin(null); | 117 | » » this.minigame.Begin(null); |
| 118 | » } | 118 | » } |
| 119 | 119 | ||
| 120 | » public·override·bool·CanUse(IUsable·console) | 120 | » public·override·bool·CanUse(IUsable·console) |
| 121 | » { | 121 | » { |
| 122 | » » return·console·is·Console; | 122 | » » return·console·is·ZiplineConsole·||·console·is·Ladder·||·console·is·PlatformConsole·||·console·is·Console·||·console·is·DoorConsole; |
| 123 | » } | 123 | » } |
| 124 | 124 | ||
| 125 | » public·override·bool·DidWin(GameOverReason·gameOverReason) | 125 | » public·override·bool·DidWin(GameOverReason·gameOverReason) |
| 126 | » { | 126 | » { |
| 127 | » » return·GameManager.Instance.DidHumansWin(gameOverReason); | 127 | » » return·GameManager.Instance.DidHumansWin(gameOverReason); |
| 128 | » } | 128 | » } |
| 129 | 129 | ||
| Offset 322, 16 lines modified | Offset 322, 16 lines modified | ||
| 322 | 322 | ||
| 323 | » public·Transform·Inner; | 323 | » public·Transform·Inner; |
| 324 | 324 | ||
| 325 | » public·bool·allowY; | 325 | » public·bool·allowY; |
| 326 | 326 | ||
| 327 | » public·bool·showY·=·true; | 327 | » public·bool·showY·=·true; |
| 328 | 328 | ||
| 329 | » [SerializeField] | ||
| 330 | » [FormerlySerializedAs("YBounds")] | 329 | » [FormerlySerializedAs("YBounds")] |
| 330 | » [SerializeField] | ||
| 331 | » private·FloatRange·ContentYBounds·=·new·FloatRange(-10f,·10f); | 331 | » private·FloatRange·ContentYBounds·=·new·FloatRange(-10f,·10f); |
| 332 | 332 | ||
| 333 | » [FormerlySerializedAs("ScrollerYRange")] | 333 | » [FormerlySerializedAs("ScrollerYRange")] |
| 334 | » public·FloatRange·ScrollbarYBounds; | 334 | » public·FloatRange·ScrollbarYBounds; |
| 335 | 335 | ||
| 336 | » [FormerlySerializedAs("ScrollerY")] | 336 | » [FormerlySerializedAs("ScrollerY")] |
| 337 | » public·Scrollbar·ScrollbarY; | 337 | » public·Scrollbar·ScrollbarY; |
| Offset 16, 15 lines modified | Offset 16, 15 lines modified | ||
| 16 | 16 | ||
| 17 | » public·void·Deteriorate(float·deltaTime) | 17 | » public·void·Deteriorate(float·deltaTime) |
| 18 | » { | 18 | » { |
| 19 | » » if·(GameData.Instance) | 19 | » » if·(GameData.Instance) |
| 20 | » » { | 20 | » » { |
| 21 | » » » foreach·(byte·b·in·this.PlayersUsing) | 21 | » » » foreach·(byte·b·in·this.PlayersUsing) |
| 22 | » » » { | 22 | » » » { |
| 23 | » » » » | 23 | » » » » NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(b); |
| 24 | » » » » if·(playerById·==·null·||·playerById.Disconnected) | 24 | » » » » if·(playerById·==·null·||·playerById.Disconnected) |
| 25 | » » » » { | 25 | » » » » { |
| 26 | » » » » » this.ToRemove.Add(b); | 26 | » » » » » this.ToRemove.Add(b); |
| 27 | » » » » } | 27 | » » » » } |
| 28 | » » » } | 28 | » » » } |
| 29 | » » » if·(this.ToRemove.Count·>·0) | 29 | » » » if·(this.ToRemove.Count·>·0) |
| 30 | » » » { | 30 | » » » { |
| Offset 24, 15 lines modified | Offset 24, 15 lines modified | ||
| 24 | » » } | 24 | » » } |
| 25 | » » int·num·=·this.Sensor.OverlapCollider(this.filter,·SecurityLogger.hits); | 25 | » » int·num·=·this.Sensor.OverlapCollider(this.filter,·SecurityLogger.hits); |
| 26 | » » int·i; | 26 | » » int·i; |
| 27 | » » int·num2; | 27 | » » int·num2; |
| 28 | » » for·(i·=·0;·i·<·num;·i·=·num2) | 28 | » » for·(i·=·0;·i·<·num;·i·=·num2) |
| 29 | » » { | 29 | » » { |
| 30 | » » » PlayerControl·playerControl·=·Enumerable.FirstOrDefault<PlayerControl>(PlayerControl.AllPlayerControls,·(PlayerControl·p)·=>·p.Collider·==·SecurityLogger.hits[i]); | 30 | » » » PlayerControl·playerControl·=·Enumerable.FirstOrDefault<PlayerControl>(PlayerControl.AllPlayerControls,·(PlayerControl·p)·=>·p.Collider·==·SecurityLogger.hits[i]); |
| 31 | » » » if·(playerControl·&&·playerControl.Data· | 31 | » » » if·(playerControl·&&·!(playerControl.Data·==·null)·&&·!playerControl.Data.IsDead·&&·this.Timers[(int)playerControl.PlayerId]·<·0f) |
| 32 | » » » { | 32 | » » » { |
| 33 | » » » » this.Timers[(int)playerControl.PlayerId]·=·this.Cooldown; | 33 | » » » » this.Timers[(int)playerControl.PlayerId]·=·this.Cooldown; |
| 34 | » » » » this.LogParent.LogPlayer(playerControl,·this.MyLocation); | 34 | » » » » this.LogParent.LogPlayer(playerControl,·this.MyLocation); |
| 35 | » » » » base.StopAllCoroutines(); | 35 | » » » » base.StopAllCoroutines(); |
| 36 | » » » » base.StartCoroutine(this.BlinkSensor()); | 36 | » » » » base.StartCoroutine(this.BlinkSensor()); |
| 37 | » » » } | 37 | » » » } |
| 38 | » » » num2·=·i·+·1; | 38 | » » » num2·=·i·+·1; |
| Offset 320, 16 lines modified | Offset 320, 16 lines modified | ||
| 320 | 320 | ||
| 321 | » private·const·float·PingTimeoutSeconds·=·5f; | 321 | » private·const·float·PingTimeoutSeconds·=·5f; |
| 322 | 322 | ||
| 323 | » private·string·serverInfoFileJson; | 323 | » private·string·serverInfoFileJson; |
| 324 | 324 | ||
| 325 | » private·UpdateState·state; | 325 | » private·UpdateState·state; |
| 326 | 326 | ||
| 327 | » [Skip] | ||
| 328 | » [JsonObject] | 327 | » [JsonObject] |
| 328 | » [Skip] | ||
| 329 | » private·struct·JsonServerData | 329 | » private·struct·JsonServerData |
| 330 | » { | 330 | » { |
| 331 | » » internal·void·CleanAndMerge(IRegionInfo[]·defaultRegions) | 331 | » » internal·void·CleanAndMerge(IRegionInfo[]·defaultRegions) |
| 332 | » » { | 332 | » » { |
| 333 | » » » List<IRegionInfo>·list·=·Enumerable.ToList<IRegionInfo>(Enumerable.Where<IRegionInfo>(this.Regions,·(IRegionInfo·r)·=>·r.Validate())); | 333 | » » » List<IRegionInfo>·list·=·Enumerable.ToList<IRegionInfo>(Enumerable.Where<IRegionInfo>(this.Regions,·(IRegionInfo·r)·=>·r.Validate())); |
| 334 | » » » for·(int·i·=·defaultRegions.Length·-·1;·i·>=·0;·i--) | 334 | » » » for·(int·i·=·defaultRegions.Length·-·1;·i·>=·0;·i--) |
| 335 | » » » { | 335 | » » » { |
| Offset 1, 15 lines modified | Offset 1, 15 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·AmongUs.Data; | 2 | using·AmongUs.Data; |
| 3 | using·TMPro; | 3 | using·TMPro; |
| 4 | using·UnityEngine; | 4 | using·UnityEngine; |
| 5 | 5 | ||
| 6 | public·class·ShapeshifterPanel·:·MonoBehaviour | 6 | public·class·ShapeshifterPanel·:·MonoBehaviour |
| 7 | { | 7 | { |
| 8 | » public·void·SetPlayer(int·index,· | 8 | » public·void·SetPlayer(int·index,·NetworkedPlayerInfo·playerInfo,·Action·onShift) |
| 9 | » { | 9 | » { |
| 10 | » » this.shapeshift·=·onShift; | 10 | » » this.shapeshift·=·onShift; |
| 11 | » » this.PlayerIcon.SetFlipX(false); | 11 | » » this.PlayerIcon.SetFlipX(false); |
| 12 | » » this.PlayerIcon.ToggleName(false); | 12 | » » this.PlayerIcon.ToggleName(false); |
| 13 | » » SpriteRenderer[]·componentsInChildren·=·base.GetComponentsInChildren<SpriteRenderer>(); | 13 | » » SpriteRenderer[]·componentsInChildren·=·base.GetComponentsInChildren<SpriteRenderer>(); |
| 14 | » » for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++) | 14 | » » for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++) |
| 15 | » » { | 15 | » » { |
| Offset 207, 15 lines modified | Offset 207, 14 lines modified | ||
| 207 | 207 | ||
| 208 | » protected·virtual·void·Start() | 208 | » protected·virtual·void·Start() |
| 209 | » { | 209 | » { |
| 210 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | 210 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) |
| 211 | » » { | 211 | » » { |
| 212 | » » » DestroyableSingleton<HudManager>.Instance.Chat.ForceClosed(); | 212 | » » » DestroyableSingleton<HudManager>.Instance.Chat.ForceClosed(); |
| 213 | » » » DestroyableSingleton<HudManager>.Instance.Chat.SetVisible(false); | 213 | » » » DestroyableSingleton<HudManager>.Instance.Chat.SetVisible(false); |
| 214 | » » » DestroyableSingleton<HudManager>.Instance.GameSettings.gameObject.SetActive(false); | ||
| 215 | » » } | 214 | » » } |
| 216 | » » foreach·(DeconSystem·deconSystem·in·base.GetComponentsInChildren<DeconSystem>()) | 215 | » » foreach·(DeconSystem·deconSystem·in·base.GetComponentsInChildren<DeconSystem>()) |
| 217 | » » { | 216 | » » { |
| 218 | » » » this.Systems.Add(deconSystem.TargetSystem,·deconSystem); | 217 | » » » this.Systems.Add(deconSystem.TargetSystem,·deconSystem); |
| 219 | » » } | 218 | » » } |
| 220 | » } | 219 | » } |
| 221 | 220 | ||
| Offset 383, 15 lines modified | Offset 382, 15 lines modified | ||
| 383 | » } | 382 | » } |
| 384 | 383 | ||
| 385 | » public·void·Begin() | 384 | » public·void·Begin() |
| 386 | » { | 385 | » { |
| 387 | » » this.numScans·=·0; | 386 | » » this.numScans·=·0; |
| 388 | » » this.AssignTaskIndexes(); | 387 | » » this.AssignTaskIndexes(); |
| 389 | » » IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions; | 388 | » » IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions; |
| 390 | » » List< | 389 | » » List<NetworkedPlayerInfo>·allPlayers·=·GameData.Instance.AllPlayers; |
| 391 | » » HashSet<TaskTypes>·hashSet·=·new·HashSet<TaskTypes>(); | 390 | » » HashSet<TaskTypes>·hashSet·=·new·HashSet<TaskTypes>(); |
| 392 | » » List<byte>·list·=·new·List<byte>(10); | 391 | » » List<byte>·list·=·new·List<byte>(10); |
| 393 | » » List<NormalPlayerTask>·list2·=·Enumerable.ToList<NormalPlayerTask>(this.CommonTasks); | 392 | » » List<NormalPlayerTask>·list2·=·Enumerable.ToList<NormalPlayerTask>(this.CommonTasks); |
| 394 | » » list2.Shuffle(0); | 393 | » » list2.Shuffle(0); |
| 395 | » » list2.ForEach(delegate(NormalPlayerTask·t) | 394 | » » list2.ForEach(delegate(NormalPlayerTask·t) |
| 396 | » » { | 395 | » » { |
| 397 | » » » t.Length·=·NormalPlayerTask.TaskLength.Common; | 396 | » » » t.Length·=·NormalPlayerTask.TaskLength.Common; |
| Offset 434, 19 lines modified | Offset 433, 19 lines modified | ||
| 434 | » » byte·b·=·0; | 433 | » » byte·b·=·0; |
| 435 | » » while·((int)b·<·allPlayers.Count) | 434 | » » while·((int)b·<·allPlayers.Count) |
| 436 | » » { | 435 | » » { |
| 437 | » » » hashSet.Clear(); | 436 | » » » hashSet.Clear(); |
| 438 | » » » list.RemoveRange(int2,·list.Count·-·int2); | 437 | » » » list.RemoveRange(int2,·list.Count·-·int2); |
| 439 | » » » this.AddTasksFromList(ref·num3,·int3,·list,·hashSet,·list3); | 438 | » » » this.AddTasksFromList(ref·num3,·int3,·list,·hashSet,·list3); |
| 440 | » » » this.AddTasksFromList(ref·num4,·num5,·list,·hashSet,·list4); | 439 | » » » this.AddTasksFromList(ref·num4,·num5,·list,·hashSet,·list4); |
| 441 | » » » | 440 | » » » NetworkedPlayerInfo·networkedPlayerInfo·=·allPlayers[(int)b]; |
| 442 | » » » if·( | 441 | » » » if·(networkedPlayerInfo.Object·&&·!networkedPlayerInfo.Object.GetComponent<DummyBehaviour>().enabled) |
| 443 | » » » { | 442 | » » » { |
| 444 | » » » » byte[]·array·=·list.ToArray(); | 443 | » » » » byte[]·array·=·list.ToArray(); |
| 445 | » » » » | 444 | » » » » networkedPlayerInfo.RpcSetTasks(array); |
| 446 | » » » } | 445 | » » » } |
| 447 | » » » b·+=·1; | 446 | » » » b·+=·1; |
| 448 | » » } | 447 | » » } |
| 449 | » » PlayerControl.LocalPlayer.cosmetics.SetAsLocalPlayer(); | 448 | » » PlayerControl.LocalPlayer.cosmetics.SetAsLocalPlayer(); |
| 450 | » } | 449 | » } |
| 451 | 450 | ||
| 452 | » private·void·AddTasksFromList(ref·int·start,·int·count,·List<byte>·tasks,·HashSet<TaskTypes>·usedTaskTypes,·List<NormalPlayerTask>·unusedTasks) | 451 | » private·void·AddTasksFromList(ref·int·start,·int·count,·List<byte>·tasks,·HashSet<TaskTypes>·usedTaskTypes,·List<NormalPlayerTask>·unusedTasks) |
| Offset 521, 15 lines modified | Offset 520, 15 lines modified | ||
| 521 | » » » » { | 520 | » » » » { |
| 522 | » » » » » systemType.Deteriorate(Time.fixedDeltaTime); | 521 | » » » » » systemType.Deteriorate(Time.fixedDeltaTime); |
| 523 | » » » » } | 522 | » » » » } |
| 524 | » » » } | 523 | » » » } |
| 525 | » » } | 524 | » » } |
| 526 | » } | 525 | » } |
| 527 | 526 | ||
| 528 | » public·virtual·float·CalculateLightRadius( | 527 | » public·virtual·float·CalculateLightRadius(NetworkedPlayerInfo·player) |
| 529 | » { | 528 | » { |
| 530 | » » if·(player·==·null·||·player.IsDead) | 529 | » » if·(player·==·null·||·player.IsDead) |
| 531 | » » { | 530 | » » { |
| 532 | » » » return·this.MaxLightRadius; | 531 | » » » return·this.MaxLightRadius; |
| 533 | » » } | 532 | » » } |
| 534 | » » if·(player.Role.IsImpostor) | 533 | » » if·(player.Role.IsImpostor) |
| 535 | » » { | 534 | » » { |
| Offset 540, 15 lines modified | Offset 539, 15 lines modified | ||
| 540 | » » if·(this.Systems.TryGetValue(SystemTypes.Electrical,·out·systemType)) | 539 | » » if·(this.Systems.TryGetValue(SystemTypes.Electrical,·out·systemType)) |
| 541 | » » { | 540 | » » { |
| 542 | » » » num·=·(float)(systemType·as·SwitchSystem).Value·/·255f; | 541 | » » » num·=·(float)(systemType·as·SwitchSystem).Value·/·255f; |
| 543 | » » } | 542 | » » } |
| 544 | » » return·Mathf.Lerp(this.MinLightRadius,·this.MaxLightRadius,·num)·*·GameOptionsManager.Instance.CurrentGameOptions.GetFloat(FloatOptionNames.CrewLightMod); | 543 | » » return·Mathf.Lerp(this.MinLightRadius,·this.MaxLightRadius,·num)·*·GameOptionsManager.Instance.CurrentGameOptions.GetFloat(FloatOptionNames.CrewLightMod); |
| 545 | » } | 544 | » } |
| 546 | 545 | ||
| 547 | » public·void·StartMeeting(PlayerControl·reporter,· | 546 | » public·void·StartMeeting(PlayerControl·reporter,·NetworkedPlayerInfo·target) |
| 548 | » { | 547 | » { |
| 549 | » » base.StartCoroutine(this.CoStartMeeting(reporter,·target)); | 548 | » » base.StartCoroutine(this.CoStartMeeting(reporter,·target)); |
| 550 | » } | 549 | » } |
| 551 | 550 | ||
| 552 | » public·PlayerTask·GetSabotageTask(SystemTypes·system) | 551 | » public·PlayerTask·GetSabotageTask(SystemTypes·system) |
| 553 | » { | 552 | » { |
| 554 | » » TaskTypes·taskTypes; | 553 | » » TaskTypes·taskTypes; |
| Offset 598, 23 lines modified | Offset 597, 23 lines modified | ||
| 598 | » » } | 597 | » » } |
| 599 | » » taskTypes·=·TaskTypes.None; | 598 | » » taskTypes·=·TaskTypes.None; |
| 600 | » » IL_005B: | 599 | » » IL_005B: |
| 601 | » » TaskTypes·taskTypeForSystem·=·taskTypes; | 600 | » » TaskTypes·taskTypeForSystem·=·taskTypes; |
| 602 | » » return·Enumerable.First<PlayerTask>(this.SpecialTasks,·(PlayerTask·task)·=>·task.TaskType·==·taskTypeForSystem); | 601 | » » return·Enumerable.First<PlayerTask>(this.SpecialTasks,·(PlayerTask·task)·=>·task.TaskType·==·taskTypeForSystem); |
| 603 | » } | 602 | » } |
| 604 | 603 | ||
| 605 | » public·IEnumerator·CoStartMeeting(PlayerControl·reporter,· | 604 | » public·IEnumerator·CoStartMeeting(PlayerControl·reporter,·NetworkedPlayerInfo·target) |
| 606 | » { | 605 | » { |
| 607 | » » while·(!MeetingHud.Instance) | 606 | » » while·(!MeetingHud.Instance) |
| 608 | » » { | 607 | » » { |
| 609 | » » » yield·return·null; | 608 | » » » yield·return·null; |
| 610 | » » } | 609 | » » } |
| 611 | » » MeetingRoomManager.Instance.RemoveSelf(); | 610 | » » MeetingRoomManager.Instance.RemoveSelf(); |
| 612 | » » DestroyableSingleton<HudManager>.Instance.InitMap(); | 611 | » » DestroyableSingleton<HudManager>.Instance.InitMap(); |
| 613 | » » MapBehaviour.Instance.SetPreMeetingPosition(PlayerControl.LocalPlayer.transform.position); | 612 | » » MapBehaviour.Instance.SetPreMeetingPosition(PlayerControl.LocalPlayer.transform.position,·false); |
| 614 | » » for·(int·i·=·0;·i·<·PlayerControl.AllPlayerControls.Count;·i++) | 613 | » » for·(int·i·=·0;·i·<·PlayerControl.AllPlayerControls.Count;·i++) |
| 615 | » » { | 614 | » » { |
| 616 | » » » PlayerControl·playerControl·=·PlayerControl.AllPlayerControls[i]; | 615 | » » » PlayerControl·playerControl·=·PlayerControl.AllPlayerControls[i]; |
| 617 | » » » if·(playerControl·!=·null) | 616 | » » » if·(playerControl·!=·null) |
| 618 | » » » { | 617 | » » » { |
| 619 | » » » » playerControl.ResetForMeeting(); | 618 | » » » » playerControl.ResetForMeeting(); |
| 620 | » » » } | 619 | » » » } |
| Offset 626, 15 lines modified | Offset 625, 15 lines modified | ||
| 626 | » » if·(Minigame.Instance) | 625 | » » if·(Minigame.Instance) |
| 627 | » » { | 626 | » » { |
| 628 | » » » Minigame.Instance.ForceClose(); | 627 | » » » Minigame.Instance.ForceClose(); |
| 629 | » » } | 628 | » » } |
| 630 | » » ShipStatus.Instance.OnMeetingCalled(); | 629 | » » ShipStatus.Instance.OnMeetingCalled(); |
| 631 | » » KillAnimation.SetMovement(reporter,·true); | 630 | » » KillAnimation.SetMovement(reporter,·true); |
| 632 | » » DeadBody[]·array·=·Object.FindObjectsOfType<DeadBody>(); | 631 | » » DeadBody[]·array·=·Object.FindObjectsOfType<DeadBody>(); |
| 633 | » » | 632 | » » NetworkedPlayerInfo[]·array2·=·Enumerable.ToArray<NetworkedPlayerInfo>(Enumerable.Select<DeadBody,·NetworkedPlayerInfo>(array,·(DeadBody·b)·=>·GameData.Instance.GetPlayerById(b.ParentId))); |
| 634 | » » for·(int·j·=·0;·j·<·array.Length;·j++) | 633 | » » for·(int·j·=·0;·j·<·array.Length;·j++) |
| 635 | » » { | 634 | » » { |
| 636 | » » » if·(array[j]·!=·null·&&·array[j].gameObject·!=·null) | 635 | » » » if·(array[j]·!=·null·&&·array[j].gameObject·!=·null) |
| 637 | » » » { | 636 | » » » { |
| 638 | » » » » Object.Destroy(array[j].gameObject); | 637 | » » » » Object.Destroy(array[j].gameObject); |
| 639 | » » » } | 638 | » » » } |
| 640 | » » » else | 639 | » » » else |
| Offset 650, 15 lines modified | Offset 649, 35 lines modified | ||
| 650 | » » » » Object.Destroy(array3[k].gameObject); | 649 | » » » » Object.Destroy(array3[k].gameObject); |
| 651 | » » » } | 650 | » » » } |
| 652 | » » » else | 651 | » » » else |
| Max diff block lines reached; 1068/6229 bytes (17.15%) of diff not shown. | |||
| Offset 40, 15 lines modified | Offset 40, 18 lines modified | ||
| 40 | » » » return; | 40 | » » » return; |
| 41 | » » } | 41 | » » } |
| 42 | » » DestroyableSingleton<FriendsListManager>.Instance.FriendCodeHidden·=·!DestroyableSingleton<FriendsListManager>.Instance.FriendCodeHidden; | 42 | » » DestroyableSingleton<FriendsListManager>.Instance.FriendCodeHidden·=·!DestroyableSingleton<FriendsListManager>.Instance.FriendCodeHidden; |
| 43 | » } | 43 | » } |
| 44 | 44 | ||
| 45 | » private·void·Update() | 45 | » private·void·Update() |
| 46 | » { | 46 | » { |
| 47 | » » if·(DestroyableSingleton<EOSManager>.Instance.HasFinishedLoginFlow()) | ||
| 48 | » » { | ||
| 47 | » » this.UpdateFriendCodeUI(); | 49 | » » » this.UpdateFriendCodeUI(); |
| 50 | » » } | ||
| 48 | » } | 51 | » } |
| 49 | 52 | ||
| 50 | » private·void·UpdateFriendCodeUI() | 53 | » private·void·UpdateFriendCodeUI() |
| 51 | » { | 54 | » { |
| 52 | » » if·(!DestroyableSingleton<EOSManager>.Instance.IsFriendsListAllowed()) | 55 | » » if·(!DestroyableSingleton<EOSManager>.Instance.IsFriendsListAllowed()) |
| 53 | » » { | 56 | » » { |
| 54 | » » » this.FriendCodeHiddenIcon.enabled·=·false; | 57 | » » » this.FriendCodeHiddenIcon.enabled·=·false; |
| Offset 6, 33 lines modified | Offset 6, 43 lines modified | ||
| 6 | { | 6 | { |
| 7 | » protected·override·IEnumerator·Animate() | 7 | » protected·override·IEnumerator·Animate() |
| 8 | » { | 8 | » { |
| 9 | » » float·num·=·Camera.main.orthographicSize·*·Camera.main.aspect·+·1f; | 9 | » » float·num·=·Camera.main.orthographicSize·*·Camera.main.aspect·+·1f; |
| 10 | » » Vector2·left·=·Vector2.left·*·num; | 10 | » » Vector2·left·=·Vector2.left·*·num; |
| 11 | » » Vector2·right·=·Vector2.right·*·num; | 11 | » » Vector2·right·=·Vector2.right·*·num; |
| 12 | » » this.Player.transform.localPosition·=·left; | 12 | » » this.Player.transform.localPosition·=·left; |
| 13 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | ||
| 14 | » » { | ||
| 13 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false); | 15 | » » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false); |
| 16 | » » } | ||
| 14 | » » yield·return·new·WaitForSeconds(0.2f); | 17 | » » yield·return·new·WaitForSeconds(0.2f); |
| 15 | » » if·(this. | 18 | » » if·(this.initData·!=·null·&&·this.initData.outfit·!=·null·&&·this.EjectSound) |
| 16 | » » { | 19 | » » { |
| 17 | » » » SoundManager.Instance.PlayDynamicSound("PlayerEjected",·this.EjectSound,·true,·new·DynamicSound.GetDynamicsFunction(this.SoundDynamics),·SoundManager.Instance.SfxChannel); | 20 | » » » SoundManager.Instance.PlayDynamicSound("PlayerEjected",·this.EjectSound,·true,·new·DynamicSound.GetDynamicsFunction(this.SoundDynamics),·SoundManager.Instance.SfxChannel); |
| 18 | » » } | 21 | » » } |
| 19 | » » yield·return·new·WaitForSeconds(0.8f); | 22 | » » yield·return·new·WaitForSeconds(0.8f); |
| 20 | » » yield·return·Effects.All(new·IEnumerator[] | 23 | » » yield·return·Effects.All(new·IEnumerator[] |
| 21 | » » { | 24 | » » { |
| 22 | » » » this.PlayerSpin(left,·right), | 25 | » » » this.PlayerSpin(left,·right), |
| 23 | » » » this.HandleText(this.Duration·*·0.3f,·this.Duration·*·0.5f) | 26 | » » » this.HandleText(this.Duration·*·0.3f,·this.Duration·*·0.5f) |
| 24 | » » }); | 27 | » » }); |
| 25 | » » if·( | 28 | » » if·(this.initData.confirmImpostor) |
| 26 | » » { | 29 | » » { |
| 27 | » » » this.ImpostorText.gameObject.SetActive(true); | 30 | » » » this.ImpostorText.gameObject.SetActive(true); |
| 28 | » » } | 31 | » » } |
| 29 | » » yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f); | 32 | » » yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f); |
| 30 | » » yield·return·new·WaitForSeconds(0.5f); | 33 | » » yield·return·new·WaitForSeconds(0.5f); |
| 34 | » » if·(DestroyableSingleton<HudManager>.InstanceExists) | ||
| 35 | » » { | ||
| 31 | » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false); | 36 | » » » yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false); |
| 37 | » » } | ||
| 38 | » » else | ||
| 39 | » » { | ||
| 40 | » » » yield·return·Effects.Wait(0.2f); | ||
| 41 | » » } | ||
| 32 | » » base.WrapUp(); | 42 | » » base.WrapUp(); |
| 33 | » » yield·break; | 43 | » » yield·break; |
| 34 | » } | 44 | » } |
| 35 | 45 | ||
| 36 | » private·IEnumerator·PlayerSpin(Vector2·left,·Vector2·right) | 46 | » private·IEnumerator·PlayerSpin(Vector2·left,·Vector2·right) |
| 37 | » { | 47 | » { |
| 38 | » » for·(float·t·=·0f;·t·<=·this.Duration;·t·+=·Time.deltaTime) | 48 | » » for·(float·t·=·0f;·t·<=·this.Duration;·t·+=·Time.deltaTime) |
| Offset 242, 15 lines modified | Offset 242, 15 lines modified | ||
| 242 | » { | 242 | » { |
| 243 | » » this.matProperties.ColorId·=·color; | 243 | » » this.matProperties.ColorId·=·color; |
| 244 | » » this.UpdateMaterial(); | 244 | » » this.UpdateMaterial(); |
| 245 | » } | 245 | » } |
| 246 | 246 | ||
| 247 | » public·bool·IsPlayingRunAnim() | 247 | » public·bool·IsPlayingRunAnim() |
| 248 | » { | 248 | » { |
| 249 | » » return·this.animator.GetCurrentAnimation()·==·this.skin.RunAnim·||·this.animator.GetCurrentAnimation()·==·this.skin.RunLeftAnim; | 249 | » » return·!(this.animator·==·null)·&&·!(this.skin·==·null)·&&·(this.animator.GetCurrentAnimation()·==·this.skin.RunAnim·||·this.animator.GetCurrentAnimation()·==·this.skin.RunLeftAnim); |
| 250 | » } | 250 | » } |
| 251 | 251 | ||
| 252 | » private·void·UpdateMaterial() | 252 | » private·void·UpdateMaterial() |
| 253 | » { | 253 | » { |
| 254 | » » PlayerMaterial.MaskType·maskType·=·this.matProperties.MaskType; | 254 | » » PlayerMaterial.MaskType·maskType·=·this.matProperties.MaskType; |
| 255 | » » if·(this.skin·&&·this.skin.MatchPlayerColor) | 255 | » » if·(this.skin·&&·this.skin.MatchPlayerColor) |
| 256 | » » { | 256 | » » { |
| Offset 58, 8 lines modified | Offset 58, 12 lines modified | ||
| 58 | » public·AnimationClip·KillStabImpostor; | 58 | » public·AnimationClip·KillStabImpostor; |
| 59 | 59 | ||
| 60 | » public·AnimationClip·KillStabVictim; | 60 | » public·AnimationClip·KillStabVictim; |
| 61 | 61 | ||
| 62 | » public·AnimationClip·KillRHMVictim; | 62 | » public·AnimationClip·KillRHMVictim; |
| 63 | 63 | ||
| 64 | » public·int·CustomKillAnimID; | 64 | » public·int·CustomKillAnimID; |
| 65 | |||
| 66 | » public·string·VisorID_KillAnim; | ||
| 67 | |||
| 68 | » public·string·HatID_KillAnim; | ||
| 65 | } | 69 | } |
| Offset 84, 16 lines modified | Offset 84, 16 lines modified | ||
| 84 | 84 | ||
| 85 | » [SerializeField] | 85 | » [SerializeField] |
| 86 | » private·bool·isMushroom; | 86 | » private·bool·isMushroom; |
| 87 | 87 | ||
| 88 | » [SerializeField] | 88 | » [SerializeField] |
| 89 | » private·float·distanceAboveJar; | 89 | » private·float·distanceAboveJar; |
| 90 | 90 | ||
| 91 | » [Header("Audio")] | ||
| 92 | » [SerializeField] | 91 | » [SerializeField] |
| 92 | » [Header("Audio")] | ||
| 93 | » private·AudioClip·pickUpSfx; | 93 | » private·AudioClip·pickUpSfx; |
| 94 | 94 | ||
| 95 | » [SerializeField] | 95 | » [SerializeField] |
| 96 | » private·AudioClip·placeCorrectSfx; | 96 | » private·AudioClip·placeCorrectSfx; |
| 97 | 97 | ||
| 98 | » private·Vector3·originalPosition; | 98 | » private·Vector3·originalPosition; |
| 99 | } | 99 | } |
| Offset 349, 20 lines modified | Offset 349, 20 lines modified | ||
| 349 | » » » audioSource.clip·=·clip; | 349 | » » » audioSource.clip·=·clip; |
| 350 | » » » audioSource.Play(); | 350 | » » » audioSource.Play(); |
| 351 | » » » this.allSources.Add(clip,·audioSource); | 351 | » » » this.allSources.Add(clip,·audioSource); |
| 352 | » » } | 352 | » » } |
| 353 | » » return·audioSource; | 353 | » » return·audioSource; |
| 354 | » } | 354 | » } |
| 355 | 355 | ||
| 356 | » public·static·float·GetSoundVolume(Vector2·soundPosition,·Vector2·listenerPosition,·float·falloffStartDistance·=·2f,·float·falloffEndDistance·=·6f) | 356 | » public·static·float·GetSoundVolume(Vector2·soundPosition,·Vector2·listenerPosition,·float·falloffStartDistance·=·2f,·float·falloffEndDistance·=·6f,·float·minVolume·=·0f) |
| 357 | » { | 357 | » { |
| 358 | » » float·num·=·Vector2.Distance(listenerPosition,·soundPosition); | 358 | » » float·num·=·Vector2.Distance(listenerPosition,·soundPosition); |
| 359 | » » if·(num·>·falloffEndDistance) | 359 | » » if·(num·>·falloffEndDistance) |
| 360 | » » { | 360 | » » { |
| 361 | » » » return· | 361 | » » » return·minVolume; |
| 362 | » » } | 362 | » » } |
| 363 | » » if·(num·>=·falloffStartDistance) | 363 | » » if·(num·>=·falloffStartDistance) |
| 364 | » » { | 364 | » » { |
| 365 | » » » float·num2·=·(num·-·falloffStartDistance)·/·(falloffEndDistance·-·falloffStartDistance); | 365 | » » » float·num2·=·(num·-·falloffStartDistance)·/·(falloffEndDistance·-·falloffStartDistance); |
| 366 | » » » return·1f·-·Mathf.Clamp01(Mathf.SmoothStep(0f,·1f,·num2)); | 366 | » » » return·1f·-·Mathf.Clamp01(Mathf.SmoothStep(0f,·1f,·num2)); |
| 367 | » » } | 367 | » » } |
| 368 | » » return·1f; | 368 | » » return·1f; |
| Offset 28, 20 lines modified | Offset 28, 20 lines modified | ||
| 28 | » » » ButtonAnimRolloverHandler·component·=·passiveButton.GetComponent<ButtonAnimRolloverHandler>(); | 28 | » » » ButtonAnimRolloverHandler·component·=·passiveButton.GetComponent<ButtonAnimRolloverHandler>(); |
| 29 | » » » component.StaticOutImage·=·pt.Image; | 29 | » » » component.StaticOutImage·=·pt.Image; |
| 30 | » » » component.RolloverAnim·=·pt.Rollover; | 30 | » » » component.RolloverAnim·=·pt.Rollover; |
| 31 | » » » component.HoverSound·=·(pt.RolloverSfx·?·pt.RolloverSfx·:·this.DefaultRolloverSound); | 31 | » » » component.HoverSound·=·(pt.RolloverSfx·?·pt.RolloverSfx·:·this.DefaultRolloverSound); |
| 32 | » » } | 32 | » » } |
| 33 | » » if·(GameManager.Instance·!=·null·&&·GameManager.Instance.IsNormal()) | 33 | » » if·(GameManager.Instance·!=·null·&&·GameManager.Instance.IsNormal()) |
| 34 | » » { | 34 | » » { |
| 35 | » » » foreach·( | 35 | » » » foreach·(NetworkedPlayerInfo·networkedPlayerInfo·in·GameData.Instance.AllPlayers) |
| 36 | » » » { | 36 | » » » { |
| 37 | » » » » if·( | 37 | » » » » if·(!(networkedPlayerInfo·==·null)·&&·!(networkedPlayerInfo.Object·==·null)·&&·!networkedPlayerInfo.Disconnected) |
| 38 | » » » » { | 38 | » » » » { |
| 39 | » » » » » | 39 | » » » » » networkedPlayerInfo.Object.NetTransform.transform.position·=·new·Vector2(-25f,·40f); |
| 40 | » » » » » | 40 | » » » » » networkedPlayerInfo.Object.NetTransform.Halt(); |
| 41 | » » » » } | 41 | » » » » } |
| 42 | » » » } | 42 | » » » } |
| 43 | » » } | 43 | » » } |
| 44 | » » base.StartCoroutine(this.RunTimer()); | 44 | » » base.StartCoroutine(this.RunTimer()); |
| 45 | » » ControllerManager.Instance.OpenOverlayMenu(base.name,·null,·this.DefaultButtonSelected,·this.ControllerSelectable,·false); | 45 | » » ControllerManager.Instance.OpenOverlayMenu(base.name,·null,·this.DefaultButtonSelected,·this.ControllerSelectable,·false); |
| 46 | » » PlayerControl.HideCursorTemporarily(); | 46 | » » PlayerControl.HideCursorTemporarily(); |
| 47 | » » ConsoleJoystick.SetMode_Menu(); | 47 | » » ConsoleJoystick.SetMode_Menu(); |
| Offset 1, 12 lines modified | Offset 1, 12 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·UnityEngine; | 2 | using·UnityEngine; |
| 3 | 3 | ||
| 4 | [RequireComponent(typeof(MeshRenderer))] | ||
| 5 | [RequireComponent(typeof(MeshFilter))] | 4 | [RequireComponent(typeof(MeshFilter))] |
| 5 | [RequireComponent(typeof(MeshRenderer))] | ||
| 6 | public·class·StarGen·:·MonoBehaviour | 6 | public·class·StarGen·:·MonoBehaviour |
| 7 | { | 7 | { |
| 8 | » public·void·Start() | 8 | » public·void·Start() |
| 9 | » { | 9 | » { |
| 10 | » » this.stars·=·new·StarGen.Stars[this.NumStars]; | 10 | » » this.stars·=·new·StarGen.Stars[this.NumStars]; |
| 11 | » » this.verts·=·new·Vector3[this.NumStars·*·4]; | 11 | » » this.verts·=·new·Vector3[this.NumStars·*·4]; |
| 12 | » » Vector2[]·array·=·new·Vector2[this.NumStars·*·4]; | 12 | » » Vector2[]·array·=·new·Vector2[this.NumStars·*·4]; |
| Offset 11, 76 lines modified | Offset 11, 86 lines modified | ||
| 11 | » private·void·OnDisable() | 11 | » private·void·OnDisable() |
| 12 | » { | 12 | » { |
| 13 | » » ControllerManager.Instance.CloseOverlayMenu(base.name); | 13 | » » ControllerManager.Instance.CloseOverlayMenu(base.name); |
| 14 | » } | 14 | » } |
| 15 | 15 | ||
| 16 | » private·void·OnEnable() | 16 | » private·void·OnEnable() |
| 17 | » { | 17 | » { |
| 18 | » » this.DisplayGameStats(); | ||
| 19 | » » ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton,·this.SelectableButtons[0],·Enumerable.ToList<UiElement>(Enumerable.Select<UiElement,·UiElement>(Enumerable.Where<UiElement>(this.SelectableButtons,·(UiElement·x)·=>·x.gameObject.activeSelf),·(UiElement·x)·=>·x)),·false); | ||
| 20 | » } | ||
| 21 | |||
| 22 | » private·static·object·GetFloatStatStr(float·stat) | ||
| 23 | » { | ||
| 24 | » » if·(float.IsNaN(stat)) | ||
| 25 | » » { | ||
| 26 | » » » return·"---"; | ||
| 27 | » » } | ||
| 28 | » » return·Mathf.Round(stat·*·1000f)·*·0.001f; | ||
| 29 | » } | ||
| 30 | |||
| 31 | » private·static·void·AppendStat(StringBuilder·str,·StringNames·statName,·object·stat,·params·object[]·additionalTranslationParams) | ||
| 32 | » { | ||
| 33 | » » str.Append("<align=left>"·+·DestroyableSingleton<TranslationController>.Instance.GetString(statName,·additionalTranslationParams).Trim()·+·"<line-height=0>"); | ||
| 34 | » » str.AppendLine(); | ||
| 35 | » » str.Append("<align=right>"·+·((stat·!=·null)·?·stat.ToString()·:·null)·+·"<line-height=1em>"); | ||
| 36 | » » str.AppendLine(); | ||
| 37 | » } | ||
| 38 | |||
| 39 | » public·void·DisplayGameStats() | ||
| 40 | » { | ||
| 18 | » » StringBuilder·stringBuilder·=·new·StringBuilder(1024); | 41 | » » StringBuilder·stringBuilder·=·new·StringBuilder(1024); |
| 19 | » » StringBuilder·stringBuilder2·=·new·StringBuilder(256); | ||
| 20 | » » foreach·(StringNames·stringNames·in·StatsPopup.BaseStatsToShow) | 42 | » » foreach·(StringNames·stringNames·in·StatsPopup.BaseStatsToShow) |
| 21 | » » { | 43 | » » { |
| 22 | » » » StatsPopup.AppendStat(stringBuilder,·string | 44 | » » » StatsPopup.AppendStat(stringBuilder,·stringNames,·StatsManager.Instance.GetStat(stringNames),·Array.Empty<object>()); |
| 23 | » » } | 45 | » » } |
| 24 | » » StatsPopup.AppendStat(stringBuilder,· | 46 | » » StatsPopup.AppendStat(stringBuilder,·StringNames.StatsFastestCrewmateWin_HideAndSeek,·StatsPopup.GetFloatStatStr(StatsManager.Instance.GetFastestHideAndSeekCrewmateWin()),·Array.Empty<object>()); |
| 25 | » » StatsPopup.AppendStat(stringBuilder,· | 47 | » » StatsPopup.AppendStat(stringBuilder,·StringNames.StatsFastestImpostorWin_HideAndSeek,·StatsPopup.GetFloatStatStr(StatsManager.Instance.GetFastestHideAndSeekImpostorWin()),·Array.Empty<object>()); |
| 26 | » » StatsPopup.AppendStat(stringBuilder,· | 48 | » » StatsPopup.AppendStat(stringBuilder,·StringNames.StatsImpostorVoteWins,·StatsManager.Instance.GetWinReason(GameOverReason.ImpostorByVote),·Array.Empty<object>()); |
| 27 | » » StatsPopup.AppendStat(stringBuilder,· | 49 | » » StatsPopup.AppendStat(stringBuilder,·StringNames.StatsImpostorKillsWins,·StatsManager.Instance.GetWinReason(GameOverReason.ImpostorByKill),·Array.Empty<object>()); |
| 28 | » » StatsPopup.AppendStat(stringBuilder,· | 50 | » » StatsPopup.AppendStat(stringBuilder,·StringNames.StatsImpostorSabotageWins,·StatsManager.Instance.GetWinReason(GameOverReason.ImpostorBySabotage),·Array.Empty<object>()); |
| 29 | » » StatsPopup.AppendStat(stringBuilder,· | 51 | » » StatsPopup.AppendStat(stringBuilder,·StringNames.StatsCrewmateVoteWins,·StatsManager.Instance.GetWinReason(GameOverReason.HumansByVote),·Array.Empty<object>()); |
| 30 | » » StatsPopup.AppendStat(stringBuilder,· | 52 | » » StatsPopup.AppendStat(stringBuilder,·StringNames.StatsCrewmateTaskWins,·StatsManager.Instance.GetWinReason(GameOverReason.HumansByTask),·Array.Empty<object>()); |
| 31 | » » StatsPopup.AppendStat(stringBuilder,· | 53 | » » StatsPopup.AppendStat(stringBuilder,·StringNames.StatsHideAndSeekCrewmateVictory,·StatsManager.Instance.GetWinReason(GameOverReason.HideAndSeek_ByTimer),·Array.Empty<object>()); |
| 32 | » » StatsPopup.AppendStat(stringBuilder,· | 54 | » » StatsPopup.AppendStat(stringBuilder,·StringNames.StatsHideAndSeekImpostorVictory,·StatsManager.Instance.GetWinReason(GameOverReason.HideAndSeek_ByKills),·Array.Empty<object>()); |
| 55 | » » this.StatsText.text·=·stringBuilder.ToString(); | ||
| 56 | » } | ||
| 57 | |||
| 58 | » public·void·DisplayRoleStats() | ||
| 59 | » { | ||
| 60 | » » StringBuilder·stringBuilder·=·new·StringBuilder(1024); | ||
| 33 | » » foreach·(RoleTypes·roleTypes·in·Enumerable.ToArray<RoleTypes>(Enumerable.Cast<RoleTypes>(Enum.GetValues(typeof(RoleTypes))))) | 61 | » » foreach·(RoleTypes·roleTypes·in·Enumerable.ToArray<RoleTypes>(Enumerable.Cast<RoleTypes>(Enum.GetValues(typeof(RoleTypes))))) |
| 34 | » » { | 62 | » » { |
| 35 | » » » if·(roleTypes·!=·RoleTypes.ImpostorGhost·&&·roleTypes·!=·RoleTypes.CrewmateGhost) | 63 | » » » if·(roleTypes·!=·RoleTypes.ImpostorGhost·&&·roleTypes·!=·RoleTypes.CrewmateGhost) |
| 36 | » » » { | 64 | » » » { |
| 37 | » » » » StringBuilder·stringBuilder | 65 | » » » » StringBuilder·stringBuilder2·=·stringBuilder; |
| 38 | » » » » StringBuilder·stringBuilder4·=·stringBuilder2; | ||
| 39 | » » » » StringNames·stringNames | 66 | » » » » StringNames·stringNames·=·StringNames.StatsRoleWins; |
| 40 | » » » » object·obj·=·StatsManager.Instance.GetRoleWinCount(roleTypes); | 67 | » » » » object·obj·=·StatsManager.Instance.GetRoleWinCount(roleTypes); |
| 41 | » » » » object[]·array2·=·new·object[1]; | 68 | » » » » object[]·array2·=·new·object[1]; |
| 42 | » » » » int·num·=·0; | 69 | » » » » int·num·=·0; |
| 43 | » » » » RoleBehaviour·role·=·DestroyableSingleton<RoleManager>.Instance.GetRole(roleTypes); | 70 | » » » » RoleBehaviour·role·=·DestroyableSingleton<RoleManager>.Instance.GetRole(roleTypes); |
| 44 | » » » » array2[num]·=·((role·!=·null)·?·role.NiceName·:·null)·??·roleTypes; | 71 | » » » » array2[num]·=·((role·!=·null)·?·role.NiceName·:·null)·??·roleTypes; |
| 45 | » » » » StatsPopup.AppendStat(stringBuilder | 72 | » » » » StatsPopup.AppendStat(stringBuilder2,·stringNames,·obj,·array2); |
| 46 | » » » } | 73 | » » » } |
| 47 | » » } | 74 | » » } |
| 48 | » » foreach·(StringNames·stringNames | 75 | » » foreach·(StringNames·stringNames2·in·StatsPopup.RoleSpecificStatsToShow) |
| 49 | » » { | 76 | » » { |
| 50 | » » » StatsPopup.AppendStat(stringBuilder,·string | 77 | » » » StatsPopup.AppendStat(stringBuilder,·stringNames2,·StatsManager.Instance.GetStat(stringNames2),·Array.Empty<object>()); |
| 51 | » » } | 78 | » » } |
| 52 | » » this.StatsText.text·=·stringBuilder.ToString(); | 79 | » » this.StatsText.text·=·stringBuilder.ToString(); |
| 53 | » » this.NumbersText.text·=·stringBuilder2.ToString(); | ||
| 54 | » » ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton); | ||
| 55 | » } | ||
| 56 | |||
| 57 | » private·static·object·GetFloatStatStr(float·stat) | ||
| 58 | » { | ||
| 59 | » » if·(float.IsNaN(stat)) | ||
| 60 | » » { | ||
| 61 | » » » return·"---"; | ||
| 62 | » » } | ||
| 63 | » » return·Mathf.Round(stat·*·1000f)·*·0.001f; | ||
| 64 | » } | ||
| 65 | |||
| 66 | » private·static·void·AppendStat(StringBuilder·str,·StringBuilder·strNums,·StringNames·statName,·object·stat,·params·object[]·additionalTranslationParams) | ||
| 67 | » { | ||
| 68 | » » str.AppendLine(DestroyableSingleton<TranslationController>.Instance.GetString(statName,·additionalTranslationParams)); | ||
| 69 | » » strNums.Append(stat); | ||
| 70 | » » strNums.AppendLine(); | ||
| 71 | » } | 80 | » } |
| 72 | 81 | ||
| 73 | » public·TextMeshPro·StatsText; | 82 | » public·TextMeshPro·StatsText; |
| 74 | 83 | ||
| 75 | » public·TextMeshPro·NumbersText; | ||
| 76 | |||
| 77 | » [Header("Console·Controller·Navigation")] | 84 | » [Header("Console·Controller·Navigation")] |
| 78 | » public·UiElement·BackButton; | 85 | » public·UiElement·BackButton; |
| 79 | 86 | ||
| 87 | » [SerializeField] | ||
| 88 | » private·UiElement[]·SelectableButtons; | ||
| 89 | |||
| 80 | » private·static·readonly·List<StringNames>·BaseStatsToShow·=·new·List<StringNames> | 90 | » private·static·readonly·List<StringNames>·BaseStatsToShow·=·new·List<StringNames> |
| 81 | » { | 91 | » { |
| 82 | » » StringNames.StatsBodiesReported, | 92 | » » StringNames.StatsBodiesReported, |
| 83 | » » StringNames.StatsEmergenciesCalled, | 93 | » » StringNames.StatsEmergenciesCalled, |
| 84 | » » StringNames.StatsTasksCompleted, | 94 | » » StringNames.StatsTasksCompleted, |
| 85 | » » StringNames.StatsAllTasksCompleted, | 95 | » » StringNames.StatsAllTasksCompleted, |
| 86 | » » StringNames.StatsSabotagesFixed, | 96 | » » StringNames.StatsSabotagesFixed, |
| Offset 51, 36 lines modified | Offset 51, 41 lines modified | ||
| 51 | » » this.logger.Warning("Failed·to·init·store·message:\r\n"·+·error.ToString()·+·"·message:·"·+·message,·null); | 51 | » » this.logger.Warning("Failed·to·init·store·message:\r\n"·+·error.ToString()·+·"·message:·"·+·message,·null); |
| 52 | » } | 52 | » } |
| 53 | 53 | ||
| 54 | » public·void·ProcessOldReceiptsRestore() | 54 | » public·void·ProcessOldReceiptsRestore() |
| 55 | » { | 55 | » { |
| 56 | » » if·(!this.initialized) | 56 | » » if·(!this.initialized) |
| 57 | » » { | 57 | » » { |
| 58 | » » » Debug.Log("UpdateInventory·::·store·manager·not·initialized"); | ||
| 58 | » » » this.logger.Warning("Tried·to·process·old·receipts·before·store·was·finished·initializing",·null); | 59 | » » » this.logger.Warning("Tried·to·process·old·receipts·before·store·was·finished·initializing",·null); |
| 59 | » » » DestroyableSingleton<EOSManager>.Instance.validateOldDLC.MarkComplete(PurchaseStates.Fail); | 60 | » » » DestroyableSingleton<EOSManager>.Instance.validateOldDLC.MarkComplete(PurchaseStates.Fail); |
| 60 | » » » return; | 61 | » » » return; |
| 61 | » » } | 62 | » » } |
| 62 | » » if·(this.extensions·==·null) | 63 | » » if·(this.extensions·==·null) |
| 63 | » » { | 64 | » » { |
| 65 | » » » Debug.Log("UpdateInventory·::·extensions·not·initialized"); | ||
| 64 | » » » this.logger.Error("Somehow·StoreManager·was·initialized,·but·no·IExtensionProvider·(this.extensions)·was·set.",·null); | 66 | » » » this.logger.Error("Somehow·StoreManager·was·initialized,·but·no·IExtensionProvider·(this.extensions)·was·set.",·null); |
| 65 | » » » DestroyableSingleton<EOSManager>.Instance.validateOldDLC.MarkComplete(PurchaseStates.Fail); | 67 | » » » DestroyableSingleton<EOSManager>.Instance.validateOldDLC.MarkComplete(PurchaseStates.Fail); |
| 66 | » » » return; | 68 | » » » return; |
| 67 | » » } | 69 | » » } |
| 68 | » » this.ProcessOldReceipts(); | 70 | » » this.ProcessOldReceipts(); |
| 69 | » } | 71 | » } |
| 70 | 72 | ||
| 71 | » public·void·ProcessOldReceipts() | 73 | » public·void·ProcessOldReceipts() |
| 72 | » { | 74 | » { |
| 75 | » » Debug.Log("UpdateInventory·::·start·process·old·receipts"); | ||
| 73 | » » if·(!this.initialized) | 76 | » » if·(!this.initialized) |
| 74 | » » { | 77 | » » { |
| 78 | » » » Debug.Log("UpdateInventory·::·tried·to·process·old·receipts·before·the·store·was·finished·initializing"); | ||
| 75 | » » » this.logger.Warning("Tried·to·process·old·receipts·before·store·was·finished·initializing",·null); | 79 | » » » this.logger.Warning("Tried·to·process·old·receipts·before·store·was·finished·initializing",·null); |
| 76 | » » » DestroyableSingleton<EOSManager>.Instance.validateOldDLC.MarkComplete(PurchaseStates.Fail); | 80 | » » » DestroyableSingleton<EOSManager>.Instance.validateOldDLC.MarkComplete(PurchaseStates.Fail); |
| 77 | » » » return; | 81 | » » » return; |
| 78 | » » } | 82 | » » } |
| 79 | » » List<string>·list·=·new·List<string>(); | 83 | » » List<string>·list·=·new·List<string>(); |
| 84 | » » Debug.Log("UpdateInventory·::·all·products·count·"·+·this.allProducts.Length.ToString()); | ||
| 80 | » » foreach·(Product·product·in·this.allProducts) | 85 | » » foreach·(Product·product·in·this.allProducts) |
| 81 | » » { | 86 | » » { |
| 82 | » » » if·(product·!=·null·&&·product.definition.type·==·ProductType.NonConsumable) | 87 | » » » if·(product·!=·null·&&·product.definition.type·==·ProductType.NonConsumable) |
| 83 | » » » { | 88 | » » » { |
| 84 | » » » » Debug.Log(string.Format("receipts:·{0}:{1}·-·{2}·-·{3}·-·{4}·-·{5}·-·{6}",·new·object[] | 89 | » » » » Debug.Log(string.Format("receipts:·{0}:{1}·-·{2}·-·{3}·-·{4}·-·{5}·-·{6}",·new·object[] |
| 85 | » » » » { | 90 | » » » » { |
| 86 | » » » » » product.hasReceipt, | 91 | » » » » » product.hasReceipt, |
| Offset 41, 22 lines modified | Offset 41, 22 lines modified | ||
| 41 | » » PetData·petData·=·product·as·PetData; | 41 | » » PetData·petData·=·product·as·PetData; |
| 42 | » » if·(petData·!=·null) | 42 | » » if·(petData·!=·null) |
| 43 | » » { | 43 | » » { |
| 44 | » » » this.hat.gameObject.SetActive(false); | 44 | » » » this.hat.gameObject.SetActive(false); |
| 45 | » » » this.visor.gameObject.SetActive(false); | 45 | » » » this.visor.gameObject.SetActive(false); |
| 46 | » » » this.skin.gameObject.SetActive(false); | 46 | » » » this.skin.gameObject.SetActive(false); |
| 47 | » » » this.pet.gameObject.SetActive(true); | 47 | » » » this.pet.gameObject.SetActive(true); |
| 48 | » » » t | 48 | » » » petData.SetPreview(this.pet,·num); |
| 49 | » » » this.pet.material·=·new·Material(petData.PreviewCrewmateColor·?·this.playerMaterial·:·this.defaultMaterial); | 49 | » » » this.pet.material·=·new·Material(petData.PreviewCrewmateColor·?·this.playerMaterial·:·this.defaultMaterial); |
| 50 | » » » PlayerMaterial.SetColors(num,·this.pet); | 50 | » » » PlayerMaterial.SetColors(num,·this.pet); |
| 51 | » » } | 51 | » » } |
| 52 | » } | 52 | » } |
| 53 | 53 | ||
| 54 | » [SerializeField] | ||
| 55 | » [Header("Cosmetic·Slots")] | 54 | » [Header("Cosmetic·Slots")] |
| 55 | » [SerializeField] | ||
| 56 | » private·HatParent·hat; | 56 | » private·HatParent·hat; |
| 57 | 57 | ||
| 58 | » [SerializeField] | 58 | » [SerializeField] |
| 59 | » private·VisorLayer·visor; | 59 | » private·VisorLayer·visor; |
| 60 | 60 | ||
| 61 | » [SerializeField] | 61 | » [SerializeField] |
| 62 | » private·SpriteRenderer·skin; | 62 | » private·SpriteRenderer·skin; |
| Offset 11, 19 lines modified | Offset 11, 14 lines modified | ||
| 11 | public·class·StoreMenu·:·DestroyableSingleton<StoreMenu> | 11 | public·class·StoreMenu·:·DestroyableSingleton<StoreMenu> |
| 12 | { | 12 | { |
| 13 | » public·void·CloseConfirm() | 13 | » public·void·CloseConfirm() |
| 14 | » { | 14 | » { |
| 15 | » » this.confirmMenu.SetActive(false); | 15 | » » this.confirmMenu.SetActive(false); |
| 16 | » » this.starConfirmMenu.SetActive(false); | 16 | » » this.starConfirmMenu.SetActive(false); |
| 17 | » » this.cosmicubePreviewMenu.gameObject.SetActive(false); | 17 | » » this.cosmicubePreviewMenu.gameObject.SetActive(false); |
| 18 | » » if·(this.selectedTab·==·StoreTab.Bundles) | ||
| 19 | » » { | ||
| 20 | » » » this.featuredMenu.SetActive(true); | ||
| 21 | » » » return; | ||
| 22 | » » } | ||
| 23 | » » this.normalMenu.SetActive(true); | 18 | » » this.normalMenu.SetActive(true); |
| 24 | » } | 19 | » } |
| 25 | 20 | ||
| 26 | » public·void·CloseWaitModal() | 21 | » public·void·CloseWaitModal() |
| 27 | » { | 22 | » { |
| 28 | » » this.plsWaitModal.gameObject.SetActive(false); | 23 | » » this.plsWaitModal.gameObject.SetActive(false); |
| 29 | » } | 24 | » } |
| Offset 520, 20 lines modified | Offset 515, 20 lines modified | ||
| 520 | » » this.allHats·=·this.GetSortedStoreCosmetics<HatData>(DestroyableSingleton<HatManager>.Instance.AllHats); | 515 | » » this.allHats·=·this.GetSortedStoreCosmetics<HatData>(DestroyableSingleton<HatManager>.Instance.AllHats); |
| 521 | » » this.allSkins·=·this.GetSortedStoreCosmetics<SkinData>(DestroyableSingleton<HatManager>.Instance.AllSkins); | 516 | » » this.allSkins·=·this.GetSortedStoreCosmetics<SkinData>(DestroyableSingleton<HatManager>.Instance.AllSkins); |
| 522 | » » this.allVisors·=·this.GetSortedStoreCosmetics<VisorData>(DestroyableSingleton<HatManager>.Instance.AllVisors); | 517 | » » this.allVisors·=·this.GetSortedStoreCosmetics<VisorData>(DestroyableSingleton<HatManager>.Instance.AllVisors); |
| 523 | » » this.allPlates·=·this.GetSortedStoreCosmetics<NamePlateData>(DestroyableSingleton<HatManager>.Instance.AllNamePlates); | 518 | » » this.allPlates·=·this.GetSortedStoreCosmetics<NamePlateData>(DestroyableSingleton<HatManager>.Instance.AllNamePlates); |
| 524 | » » this.allPets·=·this.GetSortedStoreCosmetics<PetData>(DestroyableSingleton<HatManager>.Instance.AllPets); | 519 | » » this.allPets·=·this.GetSortedStoreCosmetics<PetData>(DestroyableSingleton<HatManager>.Instance.AllPets); |
| 525 | » » this.allCubes·=·Enumerable.ToArray<CosmicubeData>(Enumerable.ThenByDescending<CosmicubeData,·DateTime>(Enumerable.OrderBy<CosmicubeData,·bool>(DestroyableSingleton<CosmicubeManager>.Instance.GetAvailableCubeData(),·(CosmicubeData·p)·=>·DataManager.Player.Purchases.GetPurchase(p.ProdId,·"")),·(CosmicubeData·p)·=>·p.GetDateCreated())); | 520 | » » this.allCubes·=·Enumerable.ToArray<CosmicubeData>(Enumerable.ThenByDescending<CosmicubeData,·DateTime>(Enumerable.OrderBy<CosmicubeData,·bool>(DestroyableSingleton<CosmicubeManager>.Instance.GetAvailableCubeData(),·(CosmicubeData·p)·=>·DataManager.Player.Purchases.GetPurchase(p.ProdId,·"")),·(CosmicubeData·p)·=>·p.GetDateCreated())); |
| 526 | » » this.allStars·=·Enumerable.ToArray<StarBundle>(Enumerable.OrderBy<StarBundle,·float>(DestroyableSingleton<HatManager>.Instance.AllStarBundles,·(StarBundle·p)·=>·p.price)); | 521 | » » this.allStars·=·Enumerable.ToArray<StarBundle>(Enumerable.OrderBy<StarBundle,·float>(DestroyableSingleton<HatManager>.Instance.AllStarBundles,·(StarBundle·p)·=>·p.price)); |
| 527 | » » this.allBundles·=·Enumerable.ToArray<BundleData>(Enumerable.Where<BundleData>(DestroyableSingleton<HatManager>.Instance.AllBundles,·(BundleData·h)·=>·!h.Free·&&·!h.NotInStore)); | 522 | » » this.allBundles·=·Enumerable.ToArray<BundleData>(Enumerable.Where<BundleData>(DestroyableSingleton<HatManager>.Instance.AllBundles,·(BundleData·h)·=>·!h.Free·&&·!h.NotInStore·&&·h.LimitedTimeAvailable.IsAvailable())); |
| 528 | » » DestroyableSingleton<HatManager>.Instance.RefreshFeatured(); | 523 | » » DestroyableSingleton<HatManager>.Instance.RefreshFeatured(); |
| 529 | » » this.allFeaturedItems·=·Enumerable.ToArray<CosmeticData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedItems); | 524 | » » this.allFeaturedItems·=·Enumerable.ToArray<CosmeticData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedItems); |
| 530 | » » this.allFeaturedCubes·=·Enumerable.ToArray<CosmicubeData>(Enumerable.Where<CosmicubeData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedCubes,·(CosmicubeData·x)·=>·x.LimitedTimeAvailable.IsAvailable())); | 525 | » » this.allFeaturedCubes·=·Enumerable.ToArray<CosmicubeData>(Enumerable.Where<CosmicubeData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedCubes,·(CosmicubeData·x)·=>·x.LimitedTimeAvailable.IsAvailable())); |
| 531 | » » this.allFeaturedBundles·=·Enumerable.ToArray<BundleData>(Enumerable.Where<BundleData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedBundles,·(BundleData·x)·=>·x.BundleSize·==·BundleSizes.Wide)); | 526 | » » this.allFeaturedBundles·=·Enumerable.ToArray<BundleData>(Enumerable.Where<BundleData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedBundles,·(BundleData·x)·=>·x.LimitedTimeAvailable.IsAvailable()·&&·x.BundleSize·==·BundleSizes.Wide)); |
| 532 | » » this.allLargeFeaturedBundles·=·Enumerable.ToArray<BundleData>(Enumerable.Where<BundleData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedBundles,·(BundleData·x)·=>·x.BundleSize·==·BundleSizes.Large)); | 527 | » » this.allLargeFeaturedBundles·=·Enumerable.ToArray<BundleData>(Enumerable.Where<BundleData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedBundles,·(BundleData·x)·=>·x.LimitedTimeAvailable.IsAvailable()·&&·x.BundleSize·==·BundleSizes.Large)); |
| 533 | » } | 528 | » } |
| 534 | 529 | ||
| 535 | » private·void·SetRefreshTimers() | 530 | » private·void·SetRefreshTimers() |
| 536 | » { | 531 | » { |
| 537 | » » Dictionary<DateTime,·List<StoreTab>>·dictionary·=·new·Dictionary<DateTime,·List<StoreTab>>(); | 532 | » » Dictionary<DateTime,·List<StoreTab>>·dictionary·=·new·Dictionary<DateTime,·List<StoreTab>>(); |
| 538 | » » this.AddRefreshTimers(dictionary,·DestroyableSingleton<HatManager>.Instance.AllHats,·new·StoreTab[]·{·StoreTab.Hats·}); | 533 | » » this.AddRefreshTimers(dictionary,·DestroyableSingleton<HatManager>.Instance.AllHats,·new·StoreTab[]·{·StoreTab.Hats·}); |
| 539 | » » this.AddRefreshTimers(dictionary,·DestroyableSingleton<HatManager>.Instance.AllSkins,·new·StoreTab[]·{·StoreTab.Skins·}); | 534 | » » this.AddRefreshTimers(dictionary,·DestroyableSingleton<HatManager>.Instance.AllSkins,·new·StoreTab[]·{·StoreTab.Skins·}); |
| Offset 765, 136 lines modified | Offset 760, 121 lines modified | ||
| 765 | » » » » Vector3·vector2·=·vector; | 760 | » » » » Vector3·vector2·=·vector; |
| 766 | » » » » IBuyable[]·array·=·this.allCubes; | 761 | » » » » IBuyable[]·array·=·this.allCubes; |
| 767 | » » » » vector·=·this.AddProductFromList(vector2,·array,·list,·-3.9f,·this.selectedTabObject.NumPerRow,·this.CubesRange,·1f,·false); | 762 | » » » » vector·=·this.AddProductFromList(vector2,·array,·list,·-3.9f,·this.selectedTabObject.NumPerRow,·this.CubesRange,·1f,·false); |
| 768 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Cosmicubes,·Array.Empty<object>()); | 763 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Cosmicubes,·Array.Empty<object>()); |
| 769 | » » » » break; | 764 | » » » » break; |
| 770 | » » » } | 765 | » » » } |
| 771 | » » » case·StoreTab.Bundles: | 766 | » » » case·StoreTab.Bundles: |
| 772 | » » » | 767 | » » » { |
| 768 | » » » » vector.y·+=·-0.975f; | ||
| 769 | » » » » Vector3·vector3·=·vector; | ||
| 770 | » » » » IBuyable[]·array·=·this.allBundles; | ||
| 771 | » » » » vector·=·this.AddProductFromList(vector3,·array,·list,·-3.9f,·this.selectedTabObject.NumPerRow,·this.BundleRange,·1f,·false); | ||
| 772 | » » » » float·num2·=·list[0].transform.position.y; | ||
| 773 | » » » » for·(int·i·=·0;·i·<·list.Count;·i++) | ||
| 773 | » » » » { | 774 | » » » » { |
| 774 | » » » » » bundlePurchaseButton.UpdateBundle(); | ||
| 775 | » » » » » bundlePurchaseButton.PassiveButton.ClickMask·=·this.FeatureTabScroller.Hitbox; | ||
| 776 | » » » » » | 775 | » » » » » if·(this.allBundles[i].BundleSize·==·BundleSizes.Wide) |
| 776 | » » » » » { | ||
| 777 | » » » » » » num2·=·list[i·-·this.selectedTabObject.NumPerRow].transform.position.y·-·list[i·-·this.selectedTabObject.NumPerRow].GetComponent<BoxCollider2D>().size.y·/·2f; | ||
| 778 | » » » » » » list[i].transform.position·=·new·Vector3(list[i].transform.position.x,·num2·-·list[i].GetComponent<BoxCollider2D>().size.y·/·2f,·list[i].transform.position.z); | ||
| 779 | » » » » » } | ||
| 777 | » » » » } | 780 | » » » » } |
| 778 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Bundles,·Array.Empty<object>()); | 781 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Bundles,·Array.Empty<object>()); |
| 779 | » » » » this.FeatureTabScroller.Inner.localScale·=·Vector3.one·*·num; | ||
| 780 | » » » » this.featuredMenu.SetActive(true); | ||
| 781 | » » » » this.normalMenu.SetActive(false); | ||
| 782 | » » » » break; | 782 | » » » » break; |
| 783 | » » » } | ||
| 783 | » » » case·StoreTab.Pets: | 784 | » » » case·StoreTab.Pets: |
| 784 | » » » { | 785 | » » » { |
| 785 | » » » » Vector3·vector | 786 | » » » » Vector3·vector4·=·vector; |
| 786 | » » » » IBuyable[]·array·=·this.allPets; | 787 | » » » » IBuyable[]·array·=·this.allPets; |
| 787 | » » » » vector·=·this.AddProductFromList(vector | 788 | » » » » vector·=·this.AddProductFromList(vector4,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false); |
| 788 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.PetLabel,·Array.Empty<object>()); | 789 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.PetLabel,·Array.Empty<object>()); |
| 789 | » » » » break; | 790 | » » » » break; |
| 790 | » » » } | 791 | » » » } |
| 791 | » » » case·StoreTab.Stars: | 792 | » » » case·StoreTab.Stars: |
| 792 | » » » { | 793 | » » » { |
| 793 | » » » » vector.y·+=·-0.975f; | 794 | » » » » vector.y·+=·-0.975f; |
| 794 | » » » » Vector3·vector | 795 | » » » » Vector3·vector5·=·vector; |
| 795 | » » » » IBuyable[]·array·=·this.allStars; | 796 | » » » » IBuyable[]·array·=·this.allStars; |
| 796 | » » » » vector·=·this.AddProductFromList(vector | 797 | » » » » vector·=·this.AddProductFromList(vector5,·array,·list,·-3.9f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false); |
| 797 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Stars,·Array.Empty<object>()); | 798 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Stars,·Array.Empty<object>()); |
| 798 | » » » » break; | 799 | » » » » break; |
| 799 | » » » } | 800 | » » » } |
| 800 | » » » case·StoreTab.Hats: | 801 | » » » case·StoreTab.Hats: |
| 801 | » » » { | 802 | » » » { |
| 802 | » » » » Vector3·vector | 803 | » » » » Vector3·vector6·=·vector; |
| 803 | » » » » IBuyable[]·array·=·this.allHats; | 804 | » » » » IBuyable[]·array·=·this.allHats; |
| 804 | » » » » vector·=·this.AddProductFromList(vector | 805 | » » » » vector·=·this.AddProductFromList(vector6,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false); |
| 805 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.HatLabel,·Array.Empty<object>()); | 806 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.HatLabel,·Array.Empty<object>()); |
| 806 | » » » » break; | 807 | » » » » break; |
| 807 | » » » } | 808 | » » » } |
| 808 | » » » case·StoreTab.Skins: | 809 | » » » case·StoreTab.Skins: |
| 809 | » » » { | 810 | » » » { |
| 810 | » » » » Vector3·vector | 811 | » » » » Vector3·vector7·=·vector; |
| 811 | » » » » IBuyable[]·array·=·this.allSkins; | 812 | » » » » IBuyable[]·array·=·this.allSkins; |
| 812 | » » » » vector·=·this.AddProductFromList(vector | 813 | » » » » vector·=·this.AddProductFromList(vector7,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false); |
| 813 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SkinLabel,·Array.Empty<object>()); | 814 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SkinLabel,·Array.Empty<object>()); |
| 814 | » » » » break; | 815 | » » » » break; |
| 815 | » » » } | 816 | » » » } |
| 816 | » » » case·StoreTab.Visors: | 817 | » » » case·StoreTab.Visors: |
| 817 | » » » { | 818 | » » » { |
| 818 | » » » » Vector3·vector | 819 | » » » » Vector3·vector8·=·vector; |
| 819 | » » » » IBuyable[]·array·=·this.allVisors; | 820 | » » » » IBuyable[]·array·=·this.allVisors; |
| 820 | » » » » vector·=·this.AddProductFromList(vector | 821 | » » » » vector·=·this.AddProductFromList(vector8,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false); |
| 821 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Visors,·Array.Empty<object>()); | 822 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Visors,·Array.Empty<object>()); |
| 822 | » » » » break; | 823 | » » » » break; |
| 823 | » » » } | 824 | » » » } |
| 824 | » » » case·StoreTab.Nameplates: | 825 | » » » case·StoreTab.Nameplates: |
| 825 | » » » { | 826 | » » » { |
| 826 | » » » » Vector3·vector | 827 | » » » » Vector3·vector9·=·vector; |
| 827 | » » » » IBuyable[]·array·=·this.allPlates; | 828 | » » » » IBuyable[]·array·=·this.allPlates; |
| 828 | » » » » vector·=·this.AddProductFromList(vector | 829 | » » » » vector·=·this.AddProductFromList(vector9,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false); |
| 829 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.NamePlates,·Array.Empty<object>()); | 830 | » » » » this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.NamePlates,·Array.Empty<object>()); |
| 830 | » » » » break; | 831 | » » » » break; |
| 831 | » » » } | 832 | » » » } |
| 832 | » » » case·StoreTab.Home: | 833 | » » » case·StoreTab.Home: |
| 834 | » » » { | ||
| 833 | » » » » this.tabHeader.text·=·string.Empty; | 835 | » » » » this.tabHeader.text·=·string.Empty; |
| 836 | » » » » TextMeshPro·textMeshPro·=·Object.Instantiate<TextMeshPro>(this.tabHeader,·this.Scroller.Inner); | ||
| 837 | » » » » textMeshPro.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.FeaturedItems,·Array.Empty<object>()); | ||
| 838 | » » » » textMeshPro.GetComponent<AspectPosition>().enabled·=·false; | ||
| 839 | » » » » textMeshPro.horizontalAlignment·=·HorizontalAlignmentOptions.Center; | ||
| 840 | » » » » textMeshPro.transform.position·=·Vector3.zero; | ||
| Max diff block lines reached; 4160/14094 bytes (29.52%) of diff not shown. | |||
| Offset 571, 18 lines modified | Offset 571, 47 lines modified | ||
| 571 | » RolesHelpIntro_02, | 571 | » RolesHelpIntro_02, |
| 572 | » RolesHelp_Scientist_01·=·1560, | 572 | » RolesHelp_Scientist_01·=·1560, |
| 573 | » RolesHelp_Scientist_02, | 573 | » RolesHelp_Scientist_02, |
| 574 | » RolesHelp_Engineer_01, | 574 | » RolesHelp_Engineer_01, |
| 575 | » RolesHelp_Engineer_02, | 575 | » RolesHelp_Engineer_02, |
| 576 | » RolesHelp_GuardianAngel_01, | 576 | » RolesHelp_GuardianAngel_01, |
| 577 | » RolesHelp_GuardianAngel_02, | 577 | » RolesHelp_GuardianAngel_02, |
| 578 | » RolesHelp_Noisemaker_01, | ||
| 579 | » RolesHelp_Noisemaker_02, | ||
| 580 | » RolesHelp_Tracker_01, | ||
| 581 | » RolesHelp_Tracker_02, | ||
| 578 | » RolesHelp_Shapeshifter_01·=·1600, | 582 | » RolesHelp_Shapeshifter_01·=·1600, |
| 579 | » RolesHelp_Shapeshifter_02, | 583 | » RolesHelp_Shapeshifter_02, |
| 584 | » RolesHelp_Phantom_01, | ||
| 585 | » RolesHelp_Phantom_02, | ||
| 580 | » RolesHelpOutro_01·=·1650, | 586 | » RolesHelpOutro_01·=·1650, |
| 581 | » RolesHelpOutro_02, | 587 | » RolesHelpOutro_02, |
| 588 | » NoisemakerRole·=·1660, | ||
| 589 | » NoisemakerBlurb, | ||
| 590 | » NoisemakerBlurbMed, | ||
| 591 | » NoisemakerBlurbLong, | ||
| 592 | » NoisemakerImpostorAlert, | ||
| 593 | » NoisemakerAlertDuration, | ||
| 594 | » PhantomAbility·=·1670, | ||
| 595 | » PhantomRole, | ||
| 596 | » PhantomBlurb, | ||
| 597 | » PhantomBlurbMed, | ||
| 598 | » PhantomBlurbLong, | ||
| 599 | » PhantomCooldown, | ||
| 600 | » PhantomDuration, | ||
| 601 | » PhantomAbilityUndo, | ||
| 602 | » TrackerAbility·=·1680, | ||
| 603 | » TrackerRole, | ||
| 604 | » TrackerBlurb, | ||
| 605 | » TrackerBlurbMed, | ||
| 606 | » TrackerBlurbLong, | ||
| 607 | » TrackerCooldown, | ||
| 608 | » TrackerDuration, | ||
| 609 | » TrackerAbilityUndo, | ||
| 610 | » TrackerDelay, | ||
| 582 | » SanctionDuration·=·1700, | 611 | » SanctionDuration·=·1700, |
| 583 | » SanctionPermanent, | 612 | » SanctionPermanent, |
| 584 | » SanctionConduct, | 613 | » SanctionConduct, |
| 585 | » SanctionImpersonationCeleb, | 614 | » SanctionImpersonationCeleb, |
| 586 | » SanctionSpamming, | 615 | » SanctionSpamming, |
| 587 | » SanctionInappropriateNameUnsportsmanlike, | 616 | » SanctionInappropriateNameUnsportsmanlike, |
| 588 | » SanctionUnsportsmanlikeConduct, | 617 | » SanctionUnsportsmanlikeConduct, |
| Offset 1305, 14 lines modified | Offset 1334, 32 lines modified | ||
| 1305 | » AccountDeleteHelp, | 1334 | » AccountDeleteHelp, |
| 1306 | » AccountUnDeleteHelp, | 1335 | » AccountUnDeleteHelp, |
| 1307 | » ConfirmDelete, | 1336 | » ConfirmDelete, |
| 1308 | » ConfirmDeleteAccounts, | 1337 | » ConfirmDeleteAccounts, |
| 1309 | » ConfirmDeleteAccountsEmpty, | 1338 | » ConfirmDeleteAccountsEmpty, |
| 1310 | » AccountRequestDelete, | 1339 | » AccountRequestDelete, |
| 1311 | » HasBeenKilled, | 1340 | » HasBeenKilled, |
| 1341 | » RoomSettingsLabel·=·3280, | ||
| 1342 | » ViewLabel, | ||
| 1343 | » RoomCodeLabel, | ||
| 1344 | » ModeLabel, | ||
| 1345 | » PrivacyLabel, | ||
| 1346 | » CapacityLabel, | ||
| 1347 | » GameSettingsLabel, | ||
| 1348 | » RoleSettingsLabel, | ||
| 1349 | » GamePresetsLabel, | ||
| 1350 | » GamePresetsDescription, | ||
| 1351 | » StandardRulesPresetDescription, | ||
| 1352 | » GameModeStandard, | ||
| 1353 | » GameModeStandardRoles, | ||
| 1354 | » GameModeCustom, | ||
| 1355 | » ReturnToLobby, | ||
| 1356 | » GameModeFlashlight, | ||
| 1357 | » HostNounLabel, | ||
| 1358 | » RoleSettingsAll, | ||
| 1312 | » ScrollList·=·3300, | 1359 | » ScrollList·=·3300, |
| 1313 | » ScrollNews, | 1360 | » ScrollNews, |
| 1314 | » AmongUsAnnouncements, | 1361 | » AmongUsAnnouncements, |
| 1315 | » AnnouncementErrorSubtitle, | 1362 | » AnnouncementErrorSubtitle, |
| 1316 | » AnnouncementErrorText, | 1363 | » AnnouncementErrorText, |
| 1317 | » ReadMoreLabel, | 1364 | » ReadMoreLabel, |
| 1318 | » ReturnToList, | 1365 | » ReturnToList, |
| Offset 1332, 14 lines modified | Offset 1379, 41 lines modified | ||
| 1332 | » InventoryLabel, | 1379 | » InventoryLabel, |
| 1333 | » StatsLabel, | 1380 | » StatsLabel, |
| 1334 | » FriendsLabel, | 1381 | » FriendsLabel, |
| 1335 | » ReportNotificationHeader, | 1382 | » ReportNotificationHeader, |
| 1336 | » ReportNotificationBody, | 1383 | » ReportNotificationBody, |
| 1337 | » MissingGuardianEmailText, | 1384 | » MissingGuardianEmailText, |
| 1338 | » AprilFoolsModeToggle, | 1385 | » AprilFoolsModeToggle, |
| 1386 | » LobbyChangeSettingNotification, | ||
| 1387 | » ImpostorsCategory·=·3350, | ||
| 1388 | » RolesCategory, | ||
| 1389 | » MeetingsCategory, | ||
| 1390 | » PlayersCategory, | ||
| 1391 | » TasksCategory, | ||
| 1392 | » GameSettingsDescription, | ||
| 1393 | » RoleSettingsDescription, | ||
| 1394 | » InfoLabel, | ||
| 1395 | » RoleQuotaLabel, | ||
| 1396 | » OverviewCategory, | ||
| 1397 | » CrewmateRolesHeader, | ||
| 1398 | » ImpostorRolesHeader, | ||
| 1399 | » ViewingLabel, | ||
| 1400 | » LocalLobbyLabel, | ||
| 1401 | » NumberRoleHeader, | ||
| 1402 | » ChanceRoleHeader, | ||
| 1403 | » WaitingForPlayers, | ||
| 1404 | » HideAndSeekModeDescription, | ||
| 1405 | » RolesRulesPresetDescription, | ||
| 1406 | » FlashlightRulesPresetDescription, | ||
| 1407 | » RoomCodeCopied, | ||
| 1408 | » FinalHideCategory, | ||
| 1409 | » LobbyChangeSettingNotificationRole, | ||
| 1410 | » StandardRulesPresetDescriptionHideAndSeek, | ||
| 1411 | » GameModeStandardSeek, | ||
| 1412 | » HostYouLabel, | ||
| 1339 | » MiningPit·=·3400, | 1413 | » MiningPit·=·3400, |
| 1340 | » Jungle, | 1414 | » Jungle, |
| 1341 | » BuildSandcastle, | 1415 | » BuildSandcastle, |
| 1342 | » FishingDock, | 1416 | » FishingDock, |
| 1343 | » CatchFish, | 1417 | » CatchFish, |
| 1344 | » CollectShells, | 1418 | » CollectShells, |
| 1345 | » LiftWeights, | 1419 | » LiftWeights, |
| Offset 1366, 14 lines modified | Offset 1440, 17 lines modified | ||
| 1366 | » WipeSand, | 1440 | » WipeSand, |
| 1367 | » ExtractFuel, | 1441 | » ExtractFuel, |
| 1368 | » MonitorMushroom, | 1442 | » MonitorMushroom, |
| 1369 | » PlayVideogame, | 1443 | » PlayVideogame, |
| Max diff block lines reached; 854/3837 bytes (22.26%) of diff not shown. | |||
| Offset 1, 66 lines modified | Offset 1, 110 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·AmongUs.GameOptions; | 2 | using·AmongUs.GameOptions; |
| 3 | using·TMPro; | 3 | using·TMPro; |
| 4 | using·UnityEngine; | 4 | using·UnityEngine; |
| 5 | 5 | ||
| 6 | public·class·StringOption·:·OptionBehaviour | 6 | public·class·StringOption·:·OptionBehaviour |
| 7 | { | 7 | { |
| 8 | » public·void· | 8 | » public·override·void·SetUpFromData(BaseGameSetting·data,·int·maskLayer) |
| 9 | » { | 9 | » { |
| 10 | » » IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions; | ||
| 11 | » » StringNames·title·=·this.Title; | ||
| 12 | » » | 10 | » » base.SetUpFromData(data,·maskLayer); |
| 11 | » » StringGameSetting·stringGameSetting·=·data·as·StringGameSetting; | ||
| 12 | » » if·(stringGameSetting·==·null) | ||
| 13 | » » { | 13 | » » { |
| 14 | » » » return; | ||
| 14 | » » » if·(title·!=·StringNames.GameTaskBarMode) | ||
| 15 | » » » { | ||
| 16 | » » » » Debug.Log("Ono,·unrecognized·setting:·"·+·this.Title.ToString()); | ||
| 17 | » » » } | ||
| 18 | » » » else | ||
| 19 | » » » { | ||
| 20 | » » » » currentGameOptions.TryGetInt(Int32OptionNames.TaskBarMode,·out·this.Value); | ||
| 21 | » » » } | ||
| 22 | » » } | ||
| 23 | » » else | ||
| 24 | » » { | ||
| 25 | » » » currentGameOptions.TryGetInt(Int32OptionNames.KillDistance,·out·this.Value); | ||
| 26 | » » } | 15 | » » } |
| 16 | » » this.Title·=·stringGameSetting.Title; | ||
| 17 | » » this.Value·=·stringGameSetting.Index; | ||
| 18 | » » this.Values·=·stringGameSetting.Values; | ||
| 19 | » » this.stringOptionName·=·stringGameSetting.OptionName; | ||
| 20 | » } | ||
| 21 | |||
| 22 | » private·void·Start() | ||
| 23 | » { | ||
| 24 | » » this.Initialize(); | ||
| 25 | » } | ||
| 26 | |||
| 27 | » public·override·void·Initialize() | ||
| 28 | » { | ||
| 29 | » » this.Value·=·(int)GameOptionsManager.Instance.CurrentGameOptions.GetValue(this.data); | ||
| 27 | » » this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>()); | 30 | » » this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>()); |
| 28 | » » this.ValueText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Values[this.Value],·Array.Empty<object>()); | 31 | » » this.ValueText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Values[this.Value],·Array.Empty<object>()); |
| 32 | » » this.AdjustButtonsActiveState(); | ||
| 29 | » } | 33 | » } |
| 30 | 34 | ||
| 31 | » private·void·FixedUpdate() | 35 | » private·void·FixedUpdate() |
| 32 | » { | 36 | » { |
| 33 | » » if·(this.oldValue·!=·this.Value) | 37 | » » if·(this.oldValue·!=·this.Value) |
| 34 | » » { | 38 | » » { |
| 35 | » » » this.oldValue·=·this.Value; | 39 | » » » this.oldValue·=·this.Value; |
| 36 | » » » this.ValueText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Values[this.Value],·Array.Empty<object>()); | 40 | » » » this.ValueText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Values[this.Value],·Array.Empty<object>()); |
| 37 | » » } | 41 | » » } |
| 38 | » } | 42 | » } |
| 39 | 43 | ||
| 40 | » public·void·Increase() | 44 | » public·void·Increase() |
| 41 | » { | 45 | » { |
| 42 | » » this.Value·=·Mathf.Clamp(this.Value·+·1,·0,·this.Values.Length·-·1); | 46 | » » this.Value·=·Mathf.Clamp(this.Value·+·1,·0,·this.Values.Length·-·1); |
| 47 | » » this.UpdateValue(); | ||
| 43 | » » this.OnValueChanged(this); | 48 | » » this.OnValueChanged(this); |
| 49 | » » this.AdjustButtonsActiveState(); | ||
| 44 | » } | 50 | » } |
| 45 | 51 | ||
| 46 | » public·void·Decrease() | 52 | » public·void·Decrease() |
| 47 | » { | 53 | » { |
| 48 | » » this.Value·=·Mathf.Clamp(this.Value·-·1,·0,·this.Values.Length·-·1); | 54 | » » this.Value·=·Mathf.Clamp(this.Value·-·1,·0,·this.Values.Length·-·1); |
| 55 | » » this.UpdateValue(); | ||
| 49 | » » this.OnValueChanged(this); | 56 | » » this.OnValueChanged(this); |
| 57 | » » this.AdjustButtonsActiveState(); | ||
| 50 | » } | 58 | » } |
| 51 | 59 | ||
| 52 | » public·override·int·GetInt() | 60 | » public·override·int·GetInt() |
| 53 | » { | 61 | » { |
| 54 | » » return·this.Value; | 62 | » » return·this.Value; |
| 55 | » } | 63 | » } |
| 56 | 64 | ||
| 65 | » private·void·UpdateValue() | ||
| 66 | » { | ||
| 67 | » » if·(this.stringOptionName·!=·Int32OptionNames.Invalid) | ||
| 68 | » » { | ||
| 69 | » » » GameOptionsManager.Instance.CurrentGameOptions.SetInt(this.stringOptionName,·this.GetInt()); | ||
| 70 | » » » return; | ||
| 71 | » » } | ||
| 72 | » » Debug.LogError("Could·not·update·value·of·"·+·this.Title.ToString()); | ||
| 73 | » } | ||
| 74 | |||
| 75 | » private·void·AdjustButtonsActiveState() | ||
| 76 | » { | ||
| 77 | » » if·(this.Value·==·0) | ||
| 78 | » » { | ||
| 79 | » » » this.MinusBtn.SetInteractable(false); | ||
| 80 | » » » this.PlusBtn.SetInteractable(true); | ||
| 81 | » » » return; | ||
| 82 | » » } | ||
| 83 | » » if·(this.Value·==·this.Values.Length·-·1) | ||
| 84 | » » { | ||
| 85 | » » » this.MinusBtn.SetInteractable(true); | ||
| 86 | » » » this.PlusBtn.SetInteractable(false); | ||
| 87 | » » » return; | ||
| 88 | » » } | ||
| 89 | » » this.MinusBtn.SetInteractable(true); | ||
| 90 | » » this.PlusBtn.SetInteractable(true); | ||
| 91 | » } | ||
| 92 | |||
| 57 | » public·TextMeshPro·TitleText; | 93 | » public·TextMeshPro·TitleText; |
| 58 | 94 | ||
| 59 | » public·TextMeshPro·ValueText; | 95 | » public·TextMeshPro·ValueText; |
| 60 | 96 | ||
| 61 | » public·StringNames[]·Values; | 97 | » public·StringNames[]·Values; |
| 62 | 98 | ||
| 63 | » public·int·Value; | 99 | » public·int·Value; |
| 64 | 100 | ||
| 65 | » private·int·oldValue·=·-1; | 101 | » private·int·oldValue·=·-1; |
| 102 | |||
| 103 | » private·Int32OptionNames·stringOptionName; | ||
| 104 | |||
| 105 | » [SerializeField] | ||
| 106 | » private·GameOptionButton·PlusBtn; | ||
| 107 | |||
| 108 | » [SerializeField] | ||
| 109 | » private·GameOptionButton·MinusBtn; | ||
| 66 | } | 110 | } |
| Offset 41, 15 lines modified | Offset 41, 15 lines modified | ||
| 41 | » » { | 41 | » » { |
| 42 | » » » this.Image.material.SetFloat("_Outline",·(float)(on·?·1·:·0)); | 42 | » » » this.Image.material.SetFloat("_Outline",·(float)(on·?·1·:·0)); |
| 43 | » » » this.Image.material.SetColor("_OutlineColor",·Color.white); | 43 | » » » this.Image.material.SetColor("_OutlineColor",·Color.white); |
| 44 | » » » this.Image.material.SetColor("_AddColor",·mainTarget·?·Color.white·:·Color.clear); | 44 | » » » this.Image.material.SetColor("_AddColor",·mainTarget·?·Color.white·:·Color.clear); |
| 45 | » » } | 45 | » » } |
| 46 | » } | 46 | » } |
| 47 | 47 | ||
| 48 | » public·float·CanUse( | 48 | » public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse) |
| 49 | » { | 49 | » { |
| 50 | » » float·num·=·float.MaxValue; | 50 | » » float·num·=·float.MaxValue; |
| 51 | » » PlayerControl·@object·=·pc.Object; | 51 | » » PlayerControl·@object·=·pc.Object; |
| 52 | » » Vector2·truePosition·=·@object.GetTruePosition(); | 52 | » » Vector2·truePosition·=·@object.GetTruePosition(); |
| 53 | » » couldUse·=·@object.CanMove·&&·base.enabled·&&·(!pc.IsDead·||·!(this.MinigamePrefab·is·EmergencyMinigame)); | 53 | » » couldUse·=·@object.CanMove·&&·base.enabled·&&·(!pc.IsDead·||·!(this.MinigamePrefab·is·EmergencyMinigame)); |
| 54 | » » canUse·=·couldUse·&&·(!this.onlyFromBelow·||·truePosition.y·<·base.transform.position.y); | 54 | » » canUse·=·couldUse·&&·(!this.onlyFromBelow·||·truePosition.y·<·base.transform.position.y); |
| 55 | » » if·(canUse) | 55 | » » if·(canUse) |
| Offset 103, 16 lines modified | Offset 103, 16 lines modified | ||
| 103 | 103 | ||
| 104 | » [SerializeField] | 104 | » [SerializeField] |
| 105 | » private·GameObject·boxOpen; | 105 | » private·GameObject·boxOpen; |
| 106 | 106 | ||
| 107 | » [SerializeField] | 107 | » [SerializeField] |
| 108 | » private·GameObject·hand; | 108 | » private·GameObject·hand; |
| 109 | 109 | ||
| 110 | » [SerializeField] | ||
| 111 | » [Header("Audio")] | 110 | » [Header("Audio")] |
| 111 | » [SerializeField] | ||
| 112 | » private·AudioClip·openToolboxSfx; | 112 | » private·AudioClip·openToolboxSfx; |
| 113 | 113 | ||
| 114 | » [SerializeField] | 114 | » [SerializeField] |
| 115 | » private·AudioClip[]·pickUpSfx; | 115 | » private·AudioClip[]·pickUpSfx; |
| 116 | 116 | ||
| 117 | » private·readonly·Controller·controller·=·new·Controller(); | 117 | » private·readonly·Controller·controller·=·new·Controller(); |
| 118 | 118 | ||
| Offset 32, 15 lines modified | Offset 32, 15 lines modified | ||
| 32 | » » this.Button·=·base.GetComponent<PassiveButton>(); | 32 | » » this.Button·=·base.GetComponent<PassiveButton>(); |
| 33 | » } | 33 | » } |
| 34 | 34 | ||
| 35 | » public·void·Start() | 35 | » public·void·Start() |
| 36 | » { | 36 | » { |
| 37 | » » if·(this.Role) | 37 | » » if·(this.Role) |
| 38 | » » { | 38 | » » { |
| 39 | » » » | 39 | » » » NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data; |
| 40 | » » » this.Overlay.enabled·=·data.Role.Role·==·this.Role.Role; | 40 | » » » this.Overlay.enabled·=·data.Role.Role·==·this.Role.Role; |
| 41 | » » » this.Overlay.sprite·=·this.CheckImage; | 41 | » » » this.Overlay.sprite·=·this.CheckImage; |
| 42 | » » » return; | 42 | » » » return; |
| 43 | » » } | 43 | » » } |
| 44 | » » PlayerTask·playerTask·=·this.FindTaskByType(); | 44 | » » PlayerTask·playerTask·=·this.FindTaskByType(); |
| 45 | » » if·(playerTask) | 45 | » » if·(playerTask) |
| 46 | » » { | 46 | » » { |
| Offset 65, 15 lines modified | Offset 65, 15 lines modified | ||
| 65 | » » { | 65 | » » { |
| 66 | » » » if·(PlayerControl.LocalPlayer.Data.Role.Role·!=·this.Role.Role) | 66 | » » » if·(PlayerControl.LocalPlayer.Data.Role.Role·!=·this.Role.Role) |
| 67 | » » » { | 67 | » » » { |
| 68 | » » » » if·(PlayerTask.DestroyTasksOfType<ImportantTextTask>(PlayerControl.LocalPlayer)·&&·!PlayerTask.PlayerHasTaskOfType<NormalPlayerTask>(PlayerControl.LocalPlayer)) | 68 | » » » » if·(PlayerTask.DestroyTasksOfType<ImportantTextTask>(PlayerControl.LocalPlayer)·&&·!PlayerTask.PlayerHasTaskOfType<NormalPlayerTask>(PlayerControl.LocalPlayer)) |
| 69 | » » » » { | 69 | » » » » { |
| 70 | » » » » » ShipStatus.Instance.Begin(); | 70 | » » » » » ShipStatus.Instance.Begin(); |
| 71 | » » » » } | 71 | » » » » } |
| 72 | » » » » PlayerControl.LocalPlayer.RpcSetRole(this.Role.Role); | 72 | » » » » PlayerControl.LocalPlayer.RpcSetRole(this.Role.Role,·false); |
| 73 | » » » » PlayerControl.LocalPlayer.transform.position·=·this.SafePositionWorld; | 73 | » » » » PlayerControl.LocalPlayer.transform.position·=·this.SafePositionWorld; |
| 74 | » » » » ImpostorGhostRole·impostorGhostRole·=·PlayerControl.LocalPlayer.Data.Role·as·ImpostorGhostRole; | 74 | » » » » ImpostorGhostRole·impostorGhostRole·=·PlayerControl.LocalPlayer.Data.Role·as·ImpostorGhostRole; |
| 75 | » » » » if·(impostorGhostRole·!=·null) | 75 | » » » » if·(impostorGhostRole·!=·null) |
| 76 | » » » » { | 76 | » » » » { |
| 77 | » » » » » impostorGhostRole.WasManuallyPicked·=·true; | 77 | » » » » » impostorGhostRole.WasManuallyPicked·=·true; |
| 78 | » » » » } | 78 | » » » » } |
| 79 | » » » } | 79 | » » » } |
| Offset 131, 21 lines modified | Offset 131, 21 lines modified | ||
| 131 | » [ContextMenu("Reset·Frisbee·Position")] | 131 | » [ContextMenu("Reset·Frisbee·Position")] |
| 132 | » private·void·ResetFrisbeePosition() | 132 | » private·void·ResetFrisbeePosition() |
| 133 | » { | 133 | » { |
| 134 | » » this.throwableFrisbee.transform.localPosition·=·this.originalFrisbeePosition; | 134 | » » this.throwableFrisbee.transform.localPosition·=·this.originalFrisbeePosition; |
| 135 | » » this.throwableFrisbee.transform.localScale·=·Vector3.one; | 135 | » » this.throwableFrisbee.transform.localScale·=·Vector3.one; |
| 136 | » } | 136 | » } |
| 137 | 137 | ||
| 138 | » [Header("Design·Values")] | ||
| 139 | » [SerializeField] | 138 | » [SerializeField] |
| 139 | » [Header("Design·Values")] | ||
| 140 | » [Range(0.5f,·0.99f)] | 140 | » [Range(0.5f,·0.99f)] |
| 141 | » private·float·pickUpAnalogThresshold·=·0.9f; | 141 | » private·float·pickUpAnalogThresshold·=·0.9f; |
| 142 | 142 | ||
| 143 | » [Header("Components")] | ||
| 144 | » [SerializeField] | 143 | » [SerializeField] |
| 144 | » [Header("Components")] | ||
| 145 | » private·PassiveButton·stuckFrisbee; | 145 | » private·PassiveButton·stuckFrisbee; |
| 146 | 146 | ||
| 147 | » [SerializeField] | 147 | » [SerializeField] |
| 148 | » private·Collider2D·throwableFrisbee; | 148 | » private·Collider2D·throwableFrisbee; |
| 149 | 149 | ||
| 150 | » [SerializeField] | 150 | » [SerializeField] |
| 151 | » private·SpriteAnim·sparkle; | 151 | » private·SpriteAnim·sparkle; |
| Offset 36, 43 lines modified | Offset 36, 45 lines modified | ||
| 36 | » » { | 36 | » » { |
| 37 | » » » DestroyableSingleton<PassiveButtonManager>.Instance.RemoveOne(this); | 37 | » » » DestroyableSingleton<PassiveButtonManager>.Instance.RemoveOne(this); |
| 38 | » » } | 38 | » » } |
| 39 | » } | 39 | » } |
| 40 | 40 | ||
| 41 | » public·void·Clear() | 41 | » public·void·Clear() |
| 42 | » { | 42 | » { |
| 43 | » » this.SetCaretPosition(0); | ||
| 43 | » » this.SetText(string.Empty,·string.Empty); | 44 | » » this.SetText(string.Empty,·string.Empty); |
| 44 | » } | 45 | » } |
| 45 | 46 | ||
| 46 | » public·void·Update() | 47 | » public·void·Update() |
| 47 | » { | 48 | » { |
| 48 | » » if·(!base.enabled) | 49 | » » if·(!base.enabled) |
| 49 | » » { | 50 | » » { |
| 50 | » » » return; | 51 | » » » return; |
| 51 | » » } | 52 | » » } |
| 52 | » » if·(!this.hasFocus) | 53 | » » if·(!this.hasFocus) |
| 53 | » » { | 54 | » » { |
| 54 | » » » return; | 55 | » » » return; |
| 55 | » » } | 56 | » » } |
| 57 | » » this.MoveCaret(); | ||
| 56 | » » if·(this.AllowPaste·&&·(Input.GetKey(KeyCode.LeftControl)·||·Input.GetKey(KeyCode.RightControl))·&&·Input.GetKeyDown(KeyCode.V)) | 58 | » » if·(this.AllowPaste·&&·(Input.GetKey(KeyCode.LeftControl)·||·Input.GetKey(KeyCode.RightControl))·&&·Input.GetKeyDown(KeyCode.V)) |
| 57 | » » { | 59 | » » { |
| 58 | » » » string·clipboardString·=·ClipboardHelper.GetClipboardString(); | 60 | » » » string·clipboardString·=·ClipboardHelper.GetClipboardString(); |
| 59 | » » » if·(!string.IsNullOrWhiteSpace(clipboardString)) | 61 | » » » if·(!string.IsNullOrWhiteSpace(clipboardString)) |
| 60 | » » » { | 62 | » » » { |
| 61 | » » » » this.SetText(this.text | 63 | » » » » this.SetText(this.text.Insert(this.caretPos,·clipboardString),·""); |
| 62 | » » » } | 64 | » » » } |
| 63 | » » } | 65 | » » } |
| 64 | » » string·inputString·=·Input.inputString; | 66 | » » string·inputString·=·Input.inputString; |
| 65 | » » if·(inputString.Length·>·0·||·this.compoText·!=·Input.compositionString) | 67 | » » if·(inputString.Length·>·0·||·this.compoText·!=·Input.compositionString) |
| 66 | » » { | 68 | » » { |
| 67 | » » » if·(this.text·==·null·||·this.text·==·"Enter·Name") | 69 | » » » if·(this.text·==·null·||·this.text·==·"Enter·Name") |
| 68 | » » » { | 70 | » » » { |
| 69 | » » » » this.text·=·""; | 71 | » » » » this.text·=·""; |
| 70 | » » » } | 72 | » » » } |
| 71 | » » » this.SetText(this.text | 73 | » » » this.SetText(this.text.Insert(this.caretPos,·inputString),·Input.compositionString); |
| 72 | » » } | 74 | » » } |
| 73 | » » if·(this.Pipe·&&·this.hasFocus) | 75 | » » if·(this.Pipe·&&·this.hasFocus) |
| 74 | » » { | 76 | » » { |
| 75 | » » » this.pipeBlinkTimer·+=·Time.deltaTime·*·2f; | 77 | » » » this.pipeBlinkTimer·+=·Time.deltaTime·*·2f; |
| 76 | » » » this.Pipe.enabled·=·(int)this.pipeBlinkTimer·%·2·==·0; | 78 | » » » this.Pipe.enabled·=·(int)this.pipeBlinkTimer·%·2·==·0; |
| 77 | » » } | 79 | » » } |
| 78 | » } | 80 | » } |
| Offset 97, 28 lines modified | Offset 99, 30 lines modified | ||
| 97 | » » » return; | 99 | » » » return; |
| 98 | » » } | 100 | » » } |
| 99 | » » if·(this.ClearOnFocus) | 101 | » » if·(this.ClearOnFocus) |
| 100 | » » { | 102 | » » { |
| 101 | » » » this.text·=·string.Empty; | 103 | » » » this.text·=·string.Empty; |
| 102 | » » » this.compoText·=·string.Empty; | 104 | » » » this.compoText·=·string.Empty; |
| 103 | » » » this.outputText.text·=·string.Empty; | 105 | » » » this.outputText.text·=·string.Empty; |
| 106 | » » » this.SetCaretPosition(0); | ||
| 104 | » » } | 107 | » » } |
| 105 | » » this.hasFocus·=·true; | 108 | » » this.hasFocus·=·true; |
| 106 | » » if·(TouchScreenKeyboard.isSupported) | 109 | » » if·(TouchScreenKeyboard.isSupported) |
| 107 | » » { | 110 | » » { |
| 108 | » » » this.keyboard·=·TouchScreenKeyboard.Open(this.text); | 111 | » » » this.keyboard·=·TouchScreenKeyboard.Open(this.text); |
| 109 | » » } | 112 | » » } |
| 110 | » » if·(this.Background) | 113 | » » if·(this.Background) |
| 111 | » » { | 114 | » » { |
| 112 | » » » this.Background.color·=·Color.green; | 115 | » » » this.Background.color·=·Color.green; |
| 113 | » » } | 116 | » » } |
| 114 | » » this.pipeBlinkTimer·=·0f; | 117 | » » this.pipeBlinkTimer·=·0f; |
| 115 | » » if·(this.Pipe) | 118 | » » if·(this.Pipe) |
| 116 | » » { | 119 | » » { |
| 117 | » » » this. | 120 | » » » this.SetPipePosition(); |
| 121 | » » » this.SetCaretPosition(this.outputText.text.Length); | ||
| 118 | » » } | 122 | » » } |
| 119 | » } | 123 | » } |
| 120 | 124 | ||
| 121 | » public·void·ForceKeyboardClose() | 125 | » public·void·ForceKeyboardClose() |
| 122 | » { | 126 | » { |
| 123 | » » if·(this.keyboard·!=·null) | 127 | » » if·(this.keyboard·!=·null) |
| 124 | » » { | 128 | » » { |
| Offset 174, 42 lines modified | Offset 178, 54 lines modified | ||
| 174 | » » } | 178 | » » } |
| 175 | » » return·false; | 179 | » » return·false; |
| 176 | » } | 180 | » } |
| 177 | 181 | ||
| 178 | » public·void·SetText(string·input,·string·inputCompo·=·"") | 182 | » public·void·SetText(string·input,·string·inputCompo·=·"") |
| 179 | » { | 183 | » { |
| 180 | » » bool·flag·=·false; | 184 | » » bool·flag·=·false; |
| 185 | » » this.AdjustCaretPosition(input.Length·-·this.text.Length); | ||
| 181 | » » char·c·=·'·'; | 186 | » » char·c·=·'·'; |
| 182 | » » this.tempTxt.Clear(); | 187 | » » this.tempTxt.Clear(); |
| 183 | » » foreach·(char·c2·in·input) | 188 | » » foreach·(char·c2·in·input) |
| 184 | » » { | 189 | » » { |
| 185 | » » » if·(c· | 190 | » » » if·(c·==·'·'·&&·c2·==·'·') |
| 191 | » » » { | ||
| 192 | » » » » this.AdjustCaretPosition(-1); | ||
| 193 | » » » } | ||
| 194 | » » » else | ||
| 186 | » » » { | 195 | » » » { |
| 187 | » » » » if·(c2·==·'\r'·||·c2·==·'\n') | 196 | » » » » if·(c2·==·'\r'·||·c2·==·'\n') |
| 188 | » » » » { | 197 | » » » » { |
| 189 | » » » » » flag·=·true; | 198 | » » » » » flag·=·true; |
| 190 | » » » » } | 199 | » » » » } |
| 191 | » » » » if·(c2·==·'\b') | 200 | » » » » if·(c2·==·'\b') |
| 192 | » » » » { | 201 | » » » » { |
| 193 | » » » » » this.tempTxt.Length·=·Math.Max(this.tempTxt.Length·-·1,·0); | 202 | » » » » » this.tempTxt.Length·=·Math.Max(this.tempTxt.Length·-·1,·0); |
| 203 | » » » » » this.AdjustCaretPosition(-1); | ||
| 194 | » » » » } | 204 | » » » » } |
| 195 | » » » » if·(this.ForceUppercase) | 205 | » » » » if·(this.ForceUppercase) |
| 196 | » » » » { | 206 | » » » » { |
| 197 | » » » » » c2·=·char.ToUpperInvariant(c2); | 207 | » » » » » c2·=·char.ToUpperInvariant(c2); |
| 198 | » » » » } | 208 | » » » » } |
| 199 | » » » » if·(this.IsCharAllowed(c2)) | 209 | » » » » if·(!this.IsCharAllowed(c2)) |
| 210 | » » » » { | ||
| 211 | » » » » » this.AdjustCaretPosition(-1); | ||
| 212 | » » » » } | ||
| 213 | » » » » else | ||
| 200 | » » » » { | 214 | » » » » { |
| 201 | » » » » » this.tempTxt.Append(c2); | 215 | » » » » » this.tempTxt.Append(c2); |
| 202 | » » » » » c·=·c2; | 216 | » » » » » c·=·c2; |
| 203 | » » » » } | 217 | » » » » } |
| 204 | » » » } | 218 | » » » } |
| 205 | » » } | 219 | » » } |
| 206 | » » if·(!this.tempTxt.ToString().Equals(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.EnterName,·Array.Empty<object>()),·StringComparison.OrdinalIgnoreCase)·&&·this.characterLimit·>·0) | 220 | » » if·(!this.tempTxt.ToString().Equals(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.EnterName,·Array.Empty<object>()),·StringComparison.OrdinalIgnoreCase)·&&·this.characterLimit·>·0) |
| 207 | » » { | 221 | » » { |
| 222 | » » » int·length·=·this.tempTxt.Length; | ||
| 208 | » » » this.tempTxt.Length·=·Math.Min(this.tempTxt.Length,·this.characterLimit); | 223 | » » » this.tempTxt.Length·=·Math.Min(this.tempTxt.Length,·this.characterLimit); |
| 224 | » » » this.AdjustCaretPosition(-(length·-·this.tempTxt.Length)); | ||
| 209 | » » } | 225 | » » } |
| 210 | » » input·=·this.tempTxt.ToString(); | 226 | » » input·=·this.tempTxt.ToString(); |
| 211 | » » if·(!input.Equals(this.text)·||·!inputCompo.Equals(this.compoText)) | 227 | » » if·(!input.Equals(this.text)·||·!inputCompo.Equals(this.compoText)) |
| Max diff block lines reached; 3493/7009 bytes (49.84%) of diff not shown. | |||
| Offset 1, 12 lines modified | Offset 1, 12 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·UnityEngine; | 2 | using·UnityEngine; |
| 3 | 3 | ||
| 4 | [RequireComponent(typeof(MeshFilter))] | ||
| 5 | [RequireComponent(typeof(MeshRenderer))] | 4 | [RequireComponent(typeof(MeshRenderer))] |
| 5 | [RequireComponent(typeof(MeshFilter))] | ||
| 6 | public·class·TextController·:·MonoBehaviour | 6 | public·class·TextController·:·MonoBehaviour |
| 7 | { | 7 | { |
| 8 | » public·void·Update() | 8 | » public·void·Update() |
| 9 | » { | 9 | » { |
| 10 | » » if·(!this.rend) | 10 | » » if·(!this.rend) |
| 11 | » » { | 11 | » » { |
| 12 | » » » this.rend·=·base.GetComponent<MeshRenderer>(); | 12 | » » » this.rend·=·base.GetComponent<MeshRenderer>(); |
| Offset 11, 14 lines modified | Offset 11, 31 lines modified | ||
| 11 | » » if·((double)self.renderedHeight·>·100000000.0·||·(double)self.renderedHeight·<·-100000000.0) | 11 | » » if·((double)self.renderedHeight·>·100000000.0·||·(double)self.renderedHeight·<·-100000000.0) |
| 12 | » » { | 12 | » » { |
| 13 | » » » return·0f; | 13 | » » » return·0f; |
| 14 | » » } | 14 | » » } |
| 15 | » » return·self.renderedHeight; | 15 | » » return·self.renderedHeight; |
| 16 | » } | 16 | » } |
| 17 | 17 | ||
| 18 | » public·static·Vector2·CursorPos(this·TextMeshPro·self,·int·caretPos) | ||
| 19 | » { | ||
| 20 | » » if·(self.textInfo·==·null·||·self.textInfo.lineCount·==·0·||·self.textInfo.lineInfo[0].characterCount·<=·0) | ||
| 21 | » » { | ||
| 22 | » » » return·Vector2.zero; | ||
| 23 | » » } | ||
| 24 | » » if·(self.textInfo.lineCount·==·2) | ||
| 25 | » » { | ||
| 26 | » » » return·new·Vector2(self.textInfo.characterInfo[caretPos·-·1].topRight.x·-·0.01f,·(float)Mathf.Abs(self.textInfo.characterInfo[caretPos·-·1].lineNumber·-·1)·*·0.24f); | ||
| 27 | » » } | ||
| 28 | » » if·(caretPos·==·0) | ||
| 29 | » » { | ||
| 30 | » » » return·new·Vector2(self.textInfo.characterInfo[0].topLeft.x·-·0.01f,·0.12f); | ||
| 31 | » » } | ||
| 32 | » » return·new·Vector2(self.textInfo.characterInfo[caretPos·-·1].topRight.x·-·0.01f,·0.12f); | ||
| 33 | » } | ||
| 34 | |||
| 18 | » public·static·Vector2·CursorPos(this·TextMeshPro·self) | 35 | » public·static·Vector2·CursorPos(this·TextMeshPro·self) |
| 19 | » { | 36 | » { |
| 20 | » » if·(self.textInfo·==·null·||·self.textInfo.lineCount·==·0·||·self.textInfo.lineInfo[0].characterCount·<=·0) | 37 | » » if·(self.textInfo·==·null·||·self.textInfo.lineCount·==·0·||·self.textInfo.lineInfo[0].characterCount·<=·0) |
| 21 | » » { | 38 | » » { |
| 22 | » » » return·Vector2.zero; | 39 | » » » return·Vector2.zero; |
| 23 | » » } | 40 | » » } |
| 24 | » » return·Enumerable.Last<TMP_LineInfo>(self.textInfo.lineInfo,·(TMP_LineInfo·l)·=>·l.characterCount·>·0).lineExtents.max; | 41 | » » return·Enumerable.Last<TMP_LineInfo>(self.textInfo.lineInfo,·(TMP_LineInfo·l)·=>·l.characterCount·>·0).lineExtents.max; |
| Offset 1, 69 lines modified | Offset 1, 35 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·AmongUs.GameOptions; | 2 | using·AmongUs.GameOptions; |
| 3 | using·TMPro; | 3 | using·TMPro; |
| 4 | using·UnityEngine; | 4 | using·UnityEngine; |
| 5 | 5 | ||
| 6 | public·class·ToggleOption·:·OptionBehaviour | 6 | public·class·ToggleOption·:·OptionBehaviour |
| 7 | { | 7 | { |
| 8 | » public·void· | 8 | » public·override·void·SetUpFromData(BaseGameSetting·data,·int·maskLayer) |
| 9 | » { | 9 | » { |
| 10 | » » base.SetUpFromData(data,·maskLayer); | ||
| 11 | » » CheckboxGameSetting·checkboxGameSetting·=·data·as·CheckboxGameSetting; | ||
| 12 | » » if·(checkboxGameSetting·==·null) | ||
| 10 | » » this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>()); | ||
| 11 | » » IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions; | ||
| 12 | » » StringNames·title·=·this.Title; | ||
| 13 | » » if·(title·<=·StringNames.GameAnonymousVotes) | ||
| 14 | » » { | ||
| 15 | » » » if·(title·==·StringNames.GameRecommendedSettings) | ||
| 16 | » » » { | ||
| 17 | » » » » this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.IsDefaults); | ||
| 18 | » » » » return; | ||
| 19 | » » » } | ||
| 20 | » » » switch·(title) | ||
| 21 | » » » { | ||
| 22 | » » » case·StringNames.GameConfirmImpostor: | ||
| 23 | » » » » this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.ConfirmImpostor); | ||
| 24 | » » » » return; | ||
| 25 | » » » case·StringNames.GameVisualTasks: | ||
| 26 | » » » » this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.VisualTasks); | ||
| 27 | » » » » return; | ||
| 28 | » » » case·StringNames.GameAnonymousVotes: | ||
| 29 | » » » » this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.AnonymousVotes); | ||
| 30 | » » » » return; | ||
| 31 | » » » } | ||
| 32 | » » } | ||
| 33 | » » else | ||
| 34 | » » { | 13 | » » { |
| 35 | » » » if·(title·==·StringNames.UseFlashlight) | ||
| 36 | » » » { | ||
| 37 | » » » » this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.UseFlashlight); | ||
| 38 | » » » | 14 | » » » return; |
| 39 | » » » } | ||
| 40 | » » » switch·(title) | ||
| 41 | » » » { | ||
| 42 | » » » case·StringNames.SeekerFinalVents: | ||
| 43 | » » » » this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.SeekerFinalVents); | ||
| 44 | » » » » return; | ||
| 45 | » » » case·StringNames.SeekerFinalMap: | ||
| 46 | » » » » this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.SeekerFinalMap); | ||
| 47 | » » » » return; | ||
| 48 | » » » case·StringNames.CrewmateVentCooldown: | ||
| 49 | » » » » break; | ||
| 50 | » » » case·StringNames.SeekerPings: | ||
| 51 | » » » » this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.SeekerPings); | ||
| 52 | » » » » return; | ||
| 53 | » » » default: | ||
| 54 | » » » » if·(title·==·StringNames.ShowCrewmateNames) | ||
| 55 | » » » » { | ||
| 56 | » » » » » this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.ShowCrewmateNames); | ||
| 57 | » » » » » return; | ||
| 58 | » » » » } | ||
| 59 | » » » » break; | ||
| 60 | » » » } | ||
| 61 | » » } | 15 | » » } |
| 62 | » » | 16 | » » this.Title·=·checkboxGameSetting.Title; |
| 17 | » » this.boolOptionName·=·checkboxGameSetting.OptionName; | ||
| 18 | » } | ||
| 19 | |||
| 20 | » private·void·Start() | ||
| 21 | » { | ||
| 22 | » » this.Initialize(); | ||
| 23 | » } | ||
| 24 | |||
| 25 | » public·override·void·Initialize() | ||
| 26 | » { | ||
| 27 | » » this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>()); | ||
| 28 | » » this.CheckMark.enabled·=·GameOptionsManager.Instance.CurrentGameOptions.GetValue(this.data)·==·1f; | ||
| 63 | » } | 29 | » } |
| 64 | 30 | ||
| 65 | » private·void·FixedUpdate() | 31 | » private·void·FixedUpdate() |
| 66 | » { | 32 | » { |
| 67 | » » bool·@bool·=·this.GetBool(); | 33 | » » bool·@bool·=·this.GetBool(); |
| 68 | » » if·(this.oldValue·!=·@bool) | 34 | » » if·(this.oldValue·!=·@bool) |
| 69 | » » { | 35 | » » { |
| Offset 71, 21 lines modified | Offset 37, 34 lines modified | ||
| 71 | » » » this.CheckMark.enabled·=·@bool; | 37 | » » » this.CheckMark.enabled·=·@bool; |
| 72 | » » } | 38 | » » } |
| 73 | » } | 39 | » } |
| 74 | 40 | ||
| 75 | » public·void·Toggle() | 41 | » public·void·Toggle() |
| 76 | » { | 42 | » { |
| 77 | » » this.CheckMark.enabled·=·!this.CheckMark.enabled; | 43 | » » this.CheckMark.enabled·=·!this.CheckMark.enabled; |
| 44 | » » this.UpdateValue(); | ||
| 78 | » » this.OnValueChanged(this); | 45 | » » this.OnValueChanged(this); |
| 79 | » } | 46 | » } |
| 80 | 47 | ||
| 81 | » public·override·bool·GetBool() | 48 | » public·override·bool·GetBool() |
| 82 | » { | 49 | » { |
| 83 | » » return·this.CheckMark.enabled; | 50 | » » return·this.CheckMark.enabled; |
| 84 | » } | 51 | » } |
| 85 | 52 | ||
| 53 | » private·void·UpdateValue() | ||
| 54 | » { | ||
| 55 | » » if·(this.boolOptionName·!=·BoolOptionNames.Invalid) | ||
| 56 | » » { | ||
| 57 | » » » GameOptionsManager.Instance.CurrentGameOptions.SetBool(this.boolOptionName,·this.GetBool()); | ||
| 58 | » » » return; | ||
| 59 | » » } | ||
| 60 | » » Debug.LogError("Could·not·update·value·of·"·+·this.Title.ToString()); | ||
| 61 | » } | ||
| 62 | |||
| 86 | » public·TextMeshPro·TitleText; | 63 | » public·TextMeshPro·TitleText; |
| 87 | 64 | ||
| 88 | » public·SpriteRenderer·CheckMark; | 65 | » public·SpriteRenderer·CheckMark; |
| 89 | 66 | ||
| 90 | » private·bool·oldValue; | 67 | » private·bool·oldValue; |
| 68 | |||
| 69 | » private·BoolOptionNames·boolOptionName; | ||
| 91 | } | 70 | } |
| Offset 39, 44 lines modified | Offset 39, 44 lines modified | ||
| 39 | » » { | 39 | » » { |
| 40 | » » » yield·return·null; | 40 | » » » yield·return·null; |
| 41 | » » } | 41 | » » } |
| 42 | » » if·(DestroyableSingleton<DiscordManager>.InstanceExists) | 42 | » » if·(DestroyableSingleton<DiscordManager>.InstanceExists) |
| 43 | » » { | 43 | » » { |
| 44 | » » » DestroyableSingleton<DiscordManager>.Instance.SetHowToPlay(); | 44 | » » » DestroyableSingleton<DiscordManager>.Instance.SetHowToPlay(); |
| 45 | » » } | 45 | » » } |
| 46 | » » NormalGameOptionsV0 | 46 | » » NormalGameOptionsV08·normalGameOptionsV·=·new·NormalGameOptionsV08(new·UnityLogger()); |
| 47 | » » normalGameOptionsV.SetInt(Int32OptionNames.NumImpostors,·0); | 47 | » » normalGameOptionsV.SetInt(Int32OptionNames.NumImpostors,·0); |
| 48 | » » normalGameOptionsV.DiscussionTime·=·0; | 48 | » » normalGameOptionsV.DiscussionTime·=·0; |
| 49 | » » normalGameOptionsV.NumEmergencyMeetings·=·9; | 49 | » » normalGameOptionsV.NumEmergencyMeetings·=·9; |
| 50 | » » normalGameOptionsV.GhostsDoTasks·=·true; | 50 | » » normalGameOptionsV.GhostsDoTasks·=·true; |
| 51 | » » GameOptionsManager.Instance.CurrentGameOptions·=·normalGameOptionsV; | 51 | » » GameOptionsManager.Instance.CurrentGameOptions·=·normalGameOptionsV; |
| 52 | » » PlayerControl.LocalPlayer.RpcSetRole(RoleTypes.Crewmate); | 52 | » » PlayerControl.LocalPlayer.RpcSetRole(RoleTypes.Crewmate,·false); |
| 53 | » » PlayerControl.LocalPlayer.AdjustLighting(); | 53 | » » PlayerControl.LocalPlayer.AdjustLighting(); |
| 54 | » » PlayerControl.LocalPlayer.cosmetics.SetAsLocalPlayer(); | 54 | » » PlayerControl.LocalPlayer.cosmetics.SetAsLocalPlayer(); |
| 55 | » » for·(int·i·=·0;·i·<·ShipStatus.Instance.DummyLocations.Length;·i++) | 55 | » » for·(int·i·=·0;·i·<·ShipStatus.Instance.DummyLocations.Length;·i++) |
| 56 | » » { | 56 | » » { |
| 57 | » » » PlayerControl·playerControl·=·Object.Instantiate<PlayerControl>(this.PlayerPrefab); | 57 | » » » PlayerControl·playerControl·=·Object.Instantiate<PlayerControl>(this.PlayerPrefab); |
| 58 | » » » playerControl.PlayerId·=·(byte)GameData.Instance.GetAvailableId(); | 58 | » » » playerControl.PlayerId·=·(byte)GameData.Instance.GetAvailableId(); |
| 59 | » » » | 59 | » » » NetworkedPlayerInfo·networkedPlayerInfo·=·GameData.Instance.AddDummy(playerControl); |
| 60 | » » » AmongUsClient.Instance.Spawn(networkedPlayerInfo,·-2,·SpawnFlags.None); | ||
| 60 | » » » AmongUsClient.Instance.Spawn(playerControl,·-2,·SpawnFlags.None); | 61 | » » » AmongUsClient.Instance.Spawn(playerControl,·-2,·SpawnFlags.None); |
| 61 | » » » playerInfo.DefaultOutfit.dontCensorName·=·true; | ||
| 62 | » » » playerControl.isDummy·=·true; | 62 | » » » playerControl.isDummy·=·true; |
| 63 | » » » playerControl.transform.position·=·ShipStatus.Instance.DummyLocations[i].position; | 63 | » » » playerControl.transform.position·=·ShipStatus.Instance.DummyLocations[i].position; |
| 64 | » » » playerControl.GetComponent<DummyBehaviour>().enabled·=·true; | 64 | » » » playerControl.GetComponent<DummyBehaviour>().enabled·=·true; |
| 65 | » » » playerControl.NetTransform.enabled·=·false; | 65 | » » » playerControl.NetTransform.enabled·=·false; |
| 66 | » » » playerControl.SetName(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Dummy,·Array.Empty<object>())·+·"·"·+·(i·+·1).ToString() | 66 | » » » playerControl.SetName(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Dummy,·Array.Empty<object>())·+·"·"·+·(i·+·1).ToString()); |
| 67 | » » » byte·b·=·(byte)((i·<·(int)DataManager.Player.Customization.Color)·?·i·:·(i·+·1)); | 67 | » » » byte·b·=·(byte)((i·<·(int)DataManager.Player.Customization.Color)·?·i·:·(i·+·1)); |
| 68 | » » » playerControl.SetColor((int)b); | 68 | » » » playerControl.SetColor((int)b); |
| 69 | » » » playerControl.SetHat("",·(int)b); | 69 | » » » playerControl.SetHat("",·(int)b); |
| 70 | » » » playerControl.SetSkin("",·(int)b); | 70 | » » » playerControl.SetSkin("",·(int)b); |
| 71 | » » » playerControl.SetPet(""); | 71 | » » » playerControl.SetPet(""); |
| 72 | » » » playerControl.SetVisor("",·(int)b); | 72 | » » » playerControl.SetVisor("",·(int)b); |
| 73 | » » » playerControl.SetNamePlate(""); | 73 | » » » playerControl.SetNamePlate(""); |
| 74 | » » » playerControl.SetLevel(0U); | 74 | » » » playerControl.SetLevel(0U); |
| 75 | » » » | 75 | » » » networkedPlayerInfo.RpcSetTasks(new·byte[0]); |
| 76 | » » } | 76 | » » } |
| 77 | » » yield·return·ShipStatus.Instance.CosmeticsCache.PopulateFromPlayers(); | 77 | » » yield·return·ShipStatus.Instance.CosmeticsCache.PopulateFromPlayers(); |
| 78 | » » ShipStatus.Instance.Begin(); | 78 | » » ShipStatus.Instance.Begin(); |
| 79 | » » GameManager.Instance.StartGame(); | 79 | » » GameManager.Instance.StartGame(); |
| 80 | » » ShipStatus.Instance.StartSFX(); | 80 | » » ShipStatus.Instance.StartSFX(); |
| 81 | » » global::Logger.GlobalInstance.Info(string.Format("Started·Freeplay·Game·in·{0}",·(MapNames)AmongUsClient.Instance.TutorialMapId),·null); | 81 | » » global::Logger.GlobalInstance.Info(string.Format("Started·Freeplay·Game·in·{0}",·(MapNames)AmongUsClient.Instance.TutorialMapId),·null); |
| 82 | » » yield·break; | 82 | » » yield·break; |
| Offset 105, 15 lines modified | Offset 105, 15 lines modified | ||
| 105 | » » » else | 105 | » » » else |
| 106 | » » » { | 106 | » » » { |
| 107 | » » » » buttonBehavior.gameObject.SetActive(false); | 107 | » » » » buttonBehavior.gameObject.SetActive(false); |
| 108 | » » » } | 108 | » » » } |
| 109 | » » } | 109 | » » } |
| 110 | » } | 110 | » } |
| 111 | 111 | ||
| 112 | » public·float·CanUse( | 112 | » public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse) |
| 113 | » { | 113 | » { |
| 114 | » » float·num·=·float.MaxValue; | 114 | » » float·num·=·float.MaxValue; |
| 115 | » » PlayerControl·@object·=·pc.Object; | 115 | » » PlayerControl·@object·=·pc.Object; |
| 116 | » » couldUse·=·pc.Role.CanVent·&&·GameManager.Instance.LogicUsables.CanUse(this,·@object)·&&·pc.Role.CanUse(this)·&&·(!@object.MustCleanVent(this.Id)·||·(@object.inVent·&&·Vent.currentVent·==·this))·&&·!pc.IsDead·&&·(@object.CanMove·||·@object.inVent); | 116 | » » couldUse·=·pc.Role.CanVent·&&·GameManager.Instance.LogicUsables.CanUse(this,·@object)·&&·pc.Role.CanUse(this)·&&·(!@object.MustCleanVent(this.Id)·||·(@object.inVent·&&·Vent.currentVent·==·this))·&&·!pc.IsDead·&&·(@object.CanMove·||·@object.inVent); |
| 117 | » » ISystemType·systemType; | 117 | » » ISystemType·systemType; |
| 118 | » » if·(ShipStatus.Instance.Systems.TryGetValue(SystemTypes.Ventilation,·out·systemType)) | 118 | » » if·(ShipStatus.Instance.Systems.TryGetValue(SystemTypes.Ventilation,·out·systemType)) |
| 119 | » » { | 119 | » » { |
| Offset 30, 15 lines modified | Offset 30, 15 lines modified | ||
| 30 | » public·void·Deteriorate(float·deltaTime) | 30 | » public·void·Deteriorate(float·deltaTime) |
| 31 | » { | 31 | » { |
| 32 | » » if·(GameData.Instance) | 32 | » » if·(GameData.Instance) |
| 33 | » » { | 33 | » » { |
| 34 | » » » foreach·(KeyValuePair<byte,·byte>·keyValuePair·in·this.PlayersCleaningVents) | 34 | » » » foreach·(KeyValuePair<byte,·byte>·keyValuePair·in·this.PlayersCleaningVents) |
| 35 | » » » { | 35 | » » » { |
| 36 | » » » » byte·key·=·keyValuePair.Key; | 36 | » » » » byte·key·=·keyValuePair.Key; |
| 37 | » » » » | 37 | » » » » NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(key); |
| 38 | » » » » if·(playerById·==·null·||·playerById.Disconnected) | 38 | » » » » if·(playerById·==·null·||·playerById.Disconnected) |
| 39 | » » » » { | 39 | » » » » { |
| 40 | » » » » » this.ToRemove.Add(key); | 40 | » » » » » this.ToRemove.Add(key); |
| 41 | » » » » } | 41 | » » » » } |
| 42 | » » » } | 42 | » » » } |
| 43 | » » » if·(this.ToRemove.Count·>·0) | 43 | » » » if·(this.ToRemove.Count·>·0) |
| 44 | » » » { | 44 | » » » { |
| Offset 66, 15 lines modified | Offset 66, 15 lines modified | ||
| 66 | » » return·false; | 66 | » » return·false; |
| 67 | » } | 67 | » } |
| 68 | 68 | ||
| 69 | » public·bool·IsImpostorInsideVent(int·ventId) | 69 | » public·bool·IsImpostorInsideVent(int·ventId) |
| 70 | » { | 70 | » { |
| 71 | » » foreach·(KeyValuePair<byte,·byte>·keyValuePair·in·this.PlayersInsideVents) | 71 | » » foreach·(KeyValuePair<byte,·byte>·keyValuePair·in·this.PlayersInsideVents) |
| 72 | » » { | 72 | » » { |
| 73 | » » » if·((int)keyValuePair.Value·==·ventId) | 73 | » » » if·((int)keyValuePair.Value·==·ventId·&&·!this.IsInvisiblePhantomOnVent(keyValuePair.Key)) |
| 74 | » » » { | 74 | » » » { |
| 75 | » » » » return·true; | 75 | » » » » return·true; |
| 76 | » » » } | 76 | » » » } |
| 77 | » » } | 77 | » » } |
| 78 | » » return·false; | 78 | » » return·false; |
| 79 | » } | 79 | » } |
| 80 | 80 | ||
| Offset 185, 25 lines modified | Offset 185, 45 lines modified | ||
| 185 | » private·void·BootImpostorsFromVent(int·ventId) | 185 | » private·void·BootImpostorsFromVent(int·ventId) |
| 186 | » { | 186 | » { |
| 187 | » » foreach·(KeyValuePair<byte,·byte>·keyValuePair·in·Enumerable.ToArray<KeyValuePair<byte,·byte>>(this.PlayersInsideVents)) | 187 | » » foreach·(KeyValuePair<byte,·byte>·keyValuePair·in·Enumerable.ToArray<KeyValuePair<byte,·byte>>(this.PlayersInsideVents)) |
| 188 | » » { | 188 | » » { |
| 189 | » » » if·((int)keyValuePair.Value·==·ventId) | 189 | » » » if·((int)keyValuePair.Value·==·ventId) |
| 190 | » » » { | 190 | » » » { |
| 191 | » » » » byte·key·=·keyValuePair.Key; | 191 | » » » » byte·key·=·keyValuePair.Key; |
| 192 | » » » » if·(!this.IsInvisiblePhantomOnVent(key)) | ||
| 193 | » » » » { | ||
| 192 | » » » » this.PlayersInsideVents.Remove(key); | 194 | » » » » » this.PlayersInsideVents.Remove(key); |
| 193 | » » » » this.BootImpostorFromVent(ventId,·key); | 195 | » » » » » this.BootImpostorFromVent(ventId,·key); |
| 194 | » » » » this.IsDirty·=·true; | 196 | » » » » » this.IsDirty·=·true; |
| 197 | » » » » } | ||
| 195 | » » » } | 198 | » » » } |
| 196 | » » } | 199 | » » } |
| 197 | » » if·(this.IsDirty) | 200 | » » if·(this.IsDirty) |
| 198 | » » { | 201 | » » { |
| 199 | » » » this.UpdateVentArrows(); | 202 | » » » this.UpdateVentArrows(); |
| 200 | » » } | 203 | » » } |
| 201 | » } | 204 | » } |
| 202 | 205 | ||
| 206 | » private·bool·IsInvisiblePhantomOnVent(byte·playerId) | ||
| 207 | » { | ||
| 208 | » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) | ||
| 209 | » » { | ||
| 210 | » » » if·(playerControl.PlayerId·==·playerId) | ||
| 211 | » » » { | ||
| 212 | » » » » PhantomRole·phantomRole·=·playerControl.Data.Role·as·PhantomRole; | ||
| 213 | » » » » if·(phantomRole·!=·null) | ||
| 214 | » » » » { | ||
| 215 | » » » » » return·phantomRole.IsInvisible; | ||
| 216 | » » » » } | ||
| 217 | » » » » return·false; | ||
| 218 | » » » } | ||
| 219 | » » } | ||
| 220 | » » return·false; | ||
| 221 | » } | ||
| 222 | |||
| 203 | » private·void·BootImpostorFromVent(int·ventId,·byte·playerId) | 223 | » private·void·BootImpostorFromVent(int·ventId,·byte·playerId) |
| 204 | » { | 224 | » { |
| 205 | » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) | 225 | » » foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls) |
| 206 | » » { | 226 | » » { |
| 207 | » » » if·(playerControl.PlayerId·==·playerId) | 227 | » » » if·(playerControl.PlayerId·==·playerId) |
| 208 | » » » { | 228 | » » » { |
| 209 | » » » » playerControl.MyPhysics.RpcBootFromVent(ventId); | 229 | » » » » playerControl.MyPhysics.RpcBootFromVent(ventId); |
| Offset 8, 18 lines modified | Offset 8, 18 lines modified | ||
| 8 | » { | 8 | » { |
| 9 | » » string·text·=·"v"·+·Application.version; | 9 | » » string·text·=·"v"·+·Application.version; |
| 10 | » » text·+=·"s"; | 10 | » » text·+=·"s"; |
| 11 | » » if·(!global::DetectTamper.Detect()) | 11 | » » if·(!global::DetectTamper.Detect()) |
| 12 | » » { | 12 | » » { |
| 13 | » » » text·+=·"h"; | 13 | » » » text·+=·"h"; |
| 14 | » » } | 14 | » » } |
| 15 | » » if·(!string.IsNullOrEmpty("(build·num:·4 | 15 | » » if·(!string.IsNullOrEmpty("(build·num:·4431)")) |
| 16 | » » { | 16 | » » { |
| 17 | » » » text·+=·"·(build·num:·4 | 17 | » » » text·+=·"·(build·num:·4431)"; |
| 18 | » » } | 18 | » » } |
| 19 | » » this.text.text·=·text; | 19 | » » this.text.text·=·text; |
| 20 | » » Screen.sleepTimeout·=·-1; | 20 | » » Screen.sleepTimeout·=·-1; |
| 21 | » » Debug.Log("Among·Us·Version·"·+·text·+·"·Pipeline·Build·Num:·"·+·4 | 21 | » » Debug.Log("Among·Us·Version·"·+·text·+·"·Pipeline·Build·Num:·"·+·4431.ToString()); |
| 22 | » } | 22 | » } |
| 23 | 23 | ||
| 24 | » public·TextMeshPro·text; | 24 | » public·TextMeshPro·text; |
| 25 | } | 25 | } |
| Offset 1, 12 lines modified | Offset 1, 12 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·UnityEngine; | 2 | using·UnityEngine; |
| 3 | 3 | ||
| 4 | [RequireComponent(typeof(MeshRenderer))] | ||
| 5 | [RequireComponent(typeof(MeshFilter))] | 4 | [RequireComponent(typeof(MeshFilter))] |
| 5 | [RequireComponent(typeof(MeshRenderer))] | ||
| 6 | public·class·VertLineBehaviour·:·MonoBehaviour | 6 | public·class·VertLineBehaviour·:·MonoBehaviour |
| 7 | { | 7 | { |
| 8 | » public·Color·color | 8 | » public·Color·color |
| 9 | » { | 9 | » { |
| 10 | » » set | 10 | » » set |
| 11 | » » { | 11 | » » { |
| 12 | » » » this.rend.material.SetColor("_Color",·value); | 12 | » » » this.rend.material.SetColor("_Color",·value); |
| Offset 133, 23 lines modified | Offset 133, 42 lines modified | ||
| 133 | 133 | ||
| 134 | » public·void·SetLocalPlayer(bool·localPlayer) | 134 | » public·void·SetLocalPlayer(bool·localPlayer) |
| 135 | » { | 135 | » { |
| 136 | » » this.matProperties.IsLocalPlayer·=·localPlayer; | 136 | » » this.matProperties.IsLocalPlayer·=·localPlayer; |
| 137 | » » this.UpdateMaterial(); | 137 | » » this.UpdateMaterial(); |
| 138 | » } | 138 | » } |
| 139 | 139 | ||
| 140 | » public·void·SetIdleAnim(int·colorId) | ||
| 141 | » { | ||
| 142 | » » if·(!this.visorData) | ||
| 143 | » » { | ||
| 144 | » » » return; | ||
| 145 | » » } | ||
| 146 | » » this.SetVisor(this.visorData,·colorId); | ||
| 147 | » } | ||
| 148 | |||
| 140 | » public·void·SetFloorAnim() | 149 | » public·void·SetFloorAnim() |
| 141 | » { | 150 | » { |
| 142 | » » if·(!this.IsLoaded) | 151 | » » if·(!this.IsLoaded) |
| 143 | » » { | 152 | » » { |
| 144 | » » » return; | 153 | » » » return; |
| 145 | » » } | 154 | » » } |
| 146 | » » this.Image.sprite·=·this.viewAsset.GetAsset().FloorFrame; | 155 | » » this.Image.sprite·=·this.viewAsset.GetAsset().FloorFrame; |
| 147 | » } | 156 | » } |
| 148 | 157 | ||
| 158 | » public·void·SetClimbAnim(PlayerBodyTypes·bodyType) | ||
| 159 | » { | ||
| 160 | » » if·(this.options.HideDuringClimb·||·bodyType·==·PlayerBodyTypes.Horse) | ||
| 161 | » » { | ||
| 162 | » » » return; | ||
| 163 | » » } | ||
| 164 | » » base.transform.localPosition·=·new·Vector3(base.transform.localPosition.x,·base.transform.localPosition.y,·0f); | ||
| 165 | » » this.Image.sprite·=·this.viewAsset.GetAsset().ClimbFrame; | ||
| 166 | » } | ||
| 167 | |||
| 149 | » public·void·SetMaskType(PlayerMaterial.MaskType·maskType) | 168 | » public·void·SetMaskType(PlayerMaterial.MaskType·maskType) |
| 150 | » { | 169 | » { |
| 151 | » » this.matProperties.MaskType·=·maskType; | 170 | » » this.matProperties.MaskType·=·maskType; |
| 152 | » » this.UpdateMaterial(); | 171 | » » this.UpdateMaterial(); |
| 153 | » } | 172 | » } |
| 154 | 173 | ||
| 155 | » public·void·SetMaterialColor(int·color) | 174 | » public·void·SetMaterialColor(int·color) |
| Offset 6, 52 lines modified | Offset 6, 52 lines modified | ||
| 6 | 6 | ||
| 7 | public·class·VitalsMinigame·:·Minigame | 7 | public·class·VitalsMinigame·:·Minigame |
| 8 | { | 8 | { |
| 9 | » public·override·void·Begin(PlayerTask·task) | 9 | » public·override·void·Begin(PlayerTask·task) |
| 10 | » { | 10 | » { |
| 11 | » » base.Begin(task); | 11 | » » base.Begin(task); |
| 12 | » » DeadBody[]·array·=·Object.FindObjectsOfType<DeadBody>(); | 12 | » » DeadBody[]·array·=·Object.FindObjectsOfType<DeadBody>(); |
| 13 | » » List< | 13 | » » List<NetworkedPlayerInfo>·list·=·new·List<NetworkedPlayerInfo>(); |
| 14 | » » list.AddRange(GameData.Instance.AllPlayers); | 14 | » » list.AddRange(GameData.Instance.AllPlayers); |
| 15 | » » Dictionary<byte,·bool>·vitalDisconnected·=·new·Dictionary<byte,·bool>(); | 15 | » » Dictionary<byte,·bool>·vitalDisconnected·=·new·Dictionary<byte,·bool>(); |
| 16 | » » using·(List< | 16 | » » using·(List<NetworkedPlayerInfo>.Enumerator·enumerator·=·list.GetEnumerator()) |
| 17 | » » { | 17 | » » { |
| 18 | » » » while·(enumerator.MoveNext()) | 18 | » » » while·(enumerator.MoveNext()) |
| 19 | » » » { | 19 | » » » { |
| 20 | » » » » | 20 | » » » » NetworkedPlayerInfo·player·=·enumerator.Current; |
| 21 | » » » » bool·flag·=·!Enumerable.Any<DeadBody>(array,·(DeadBody·b)·=>·b.ParentId·==·player.PlayerId); | 21 | » » » » bool·flag·=·!Enumerable.Any<DeadBody>(array,·(DeadBody·b)·=>·b.ParentId·==·player.PlayerId); |
| 22 | » » » » vitalDisconnected[player.PlayerId]·=·flag·&&·(player.Disconnected·||·player.IsDead); | 22 | » » » » vitalDisconnected[player.PlayerId]·=·flag·&&·(player.Disconnected·||·player.IsDead); |
| 23 | » » » } | 23 | » » » } |
| 24 | » » } | 24 | » » } |
| 25 | » » list.Sort(delegate( | 25 | » » list.Sort(delegate(NetworkedPlayerInfo·a,·NetworkedPlayerInfo·b) |
| 26 | » » { | 26 | » » { |
| 27 | » » » if·(vitalDisconnected[a.PlayerId]·&&·!vitalDisconnected[b.PlayerId]) | 27 | » » » if·(vitalDisconnected[a.PlayerId]·&&·!vitalDisconnected[b.PlayerId]) |
| 28 | » » » { | 28 | » » » { |
| 29 | » » » » return·1; | 29 | » » » » return·1; |
| 30 | » » » } | 30 | » » » } |
| 31 | » » » if·(!vitalDisconnected[a.PlayerId]·&&·vitalDisconnected[b.PlayerId]) | 31 | » » » if·(!vitalDisconnected[a.PlayerId]·&&·vitalDisconnected[b.PlayerId]) |
| 32 | » » » { | 32 | » » » { |
| 33 | » » » » return·-1; | 33 | » » » » return·-1; |
| 34 | » » » } | 34 | » » » } |
| 35 | » » » return·0; | 35 | » » » return·0; |
| 36 | » » }); | 36 | » » }); |
| 37 | » » this.vitals·=·new·VitalsPanel[list.Count]; | 37 | » » this.vitals·=·new·VitalsPanel[list.Count]; |
| 38 | » » for·(int·i·=·0;·i·<·list.Count;·i++) | 38 | » » for·(int·i·=·0;·i·<·list.Count;·i++) |
| 39 | » » { | 39 | » » { |
| 40 | » » » | 40 | » » » NetworkedPlayerInfo·networkedPlayerInfo·=·list[i]; |
| 41 | » » » int·num·=·i·%·3; | 41 | » » » int·num·=·i·%·3; |
| 42 | » » » int·num2·=·i·/·3; | 42 | » » » int·num2·=·i·/·3; |
| 43 | » » » VitalsPanel·vitalsPanel·=·Object.Instantiate<VitalsPanel>(this.PanelPrefab,·base.transform); | 43 | » » » VitalsPanel·vitalsPanel·=·Object.Instantiate<VitalsPanel>(this.PanelPrefab,·base.transform); |
| 44 | » » » vitalsPanel.transform.localPosition·=·new·Vector3(this.XStart·+·(float)num·*·this.XOffset,·this.YStart·+·(float)num2·*·this.YOffset,·-1f); | 44 | » » » vitalsPanel.transform.localPosition·=·new·Vector3(this.XStart·+·(float)num·*·this.XOffset,·this.YStart·+·(float)num2·*·this.YOffset,·-1f); |
| 45 | » » » vitalsPanel.SetPlayer(i,· | 45 | » » » vitalsPanel.SetPlayer(i,·networkedPlayerInfo); |
| 46 | » » » if·(vitalDisconnected[ | 46 | » » » if·(vitalDisconnected[networkedPlayerInfo.PlayerId]) |
| 47 | » » » { | 47 | » » » { |
| 48 | » » » » vitalsPanel.SetDisconnected(); | 48 | » » » » vitalsPanel.SetDisconnected(); |
| 49 | » » » } | 49 | » » » } |
| 50 | » » » else·if·( | 50 | » » » else·if·(networkedPlayerInfo.IsDead) |
| 51 | » » » { | 51 | » » » { |
| 52 | » » » » vitalsPanel.SetDead(); | 52 | » » » » vitalsPanel.SetDead(); |
| 53 | » » » } | 53 | » » » } |
| 54 | » » » else | 54 | » » » else |
| 55 | » » » { | 55 | » » » { |
| 56 | » » » » vitalsPanel.SetAlive(); | 56 | » » » » vitalsPanel.SetAlive(); |
| 57 | » » » } | 57 | » » » } |
| Offset 1, 17 lines modified | Offset 1, 17 lines modified | ||
| 1 | using·System; | 1 | using·System; |
| 2 | using·AmongUs.Data; | 2 | using·AmongUs.Data; |
| 3 | using·TMPro; | 3 | using·TMPro; |
| 4 | using·UnityEngine; | 4 | using·UnityEngine; |
| 5 | 5 | ||
| 6 | public·class·VitalsPanel·:·MonoBehaviour | 6 | public·class·VitalsPanel·:·MonoBehaviour |
| 7 | { | 7 | { |
| 8 | » public· | 8 | » public·NetworkedPlayerInfo·PlayerInfo·{·get;·set;·} |
| 9 | 9 | ||
| 10 | » public·void·SetPlayer(int·index,· | 10 | » public·void·SetPlayer(int·index,·NetworkedPlayerInfo·playerInfo) |
| 11 | » { | 11 | » { |
| 12 | » » this.PlayerInfo·=·playerInfo; | 12 | » » this.PlayerInfo·=·playerInfo; |
| 13 | » » this.PlayerIcon.SetFlipX(false); | 13 | » » this.PlayerIcon.SetFlipX(false); |
| 14 | » » this.PlayerIcon.UpdateFromEitherPlayerDataOrCache(playerInfo,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ComplexUI,·false,·null); | 14 | » » this.PlayerIcon.UpdateFromEitherPlayerDataOrCache(playerInfo,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ComplexUI,·false,·null); |
| 15 | » » this.PlayerIcon.ToggleName(false); | 15 | » » this.PlayerIcon.ToggleName(false); |
| 16 | » » this.ColorBlindName.text·=·this.PlayerIcon.ColorBlindName; | 16 | » » this.ColorBlindName.text·=·this.PlayerIcon.ColorBlindName; |
| 17 | » » this.ColorBlindName.enabled·=·DataManager.Settings.Accessibility.ColorBlindMode; | 17 | » » this.ColorBlindName.enabled·=·DataManager.Settings.Accessibility.ColorBlindMode; |
| Offset 74, 15 lines modified | Offset 74, 18 lines modified | ||
| 74 | » » { | 74 | » » { |
| 75 | » » » writer.Write(keyValuePair.Key); | 75 | » » » writer.Write(keyValuePair.Key); |
| 76 | » » » for·(int·i·=·0;·i·<·3;·i++) | 76 | » » » for·(int·i·=·0;·i·<·3;·i++) |
| 77 | » » » { | 77 | » » » { |
| 78 | » » » » writer.WritePacked(keyValuePair.Value[i]); | 78 | » » » » writer.WritePacked(keyValuePair.Value[i]); |
| 79 | » » » } | 79 | » » » } |
| 80 | » » } | 80 | » » } |
| 81 | » » if·(!initialState) | ||
| 82 | » » { | ||
| 81 | » » base.ClearDirtyBits(); | 83 | » » » base.ClearDirtyBits(); |
| 84 | » » } | ||
| 82 | » » return·true; | 85 | » » return·true; |
| 83 | » } | 86 | » } |
| 84 | 87 | ||
| 85 | » public·override·void·Deserialize(MessageReader·reader,·bool·initialState) | 88 | » public·override·void·Deserialize(MessageReader·reader,·bool·initialState) |
| 86 | » { | 89 | » { |
| 87 | » » int·num·=·(int)reader.ReadByte(); | 90 | » » int·num·=·(int)reader.ReadByte(); |
| 88 | » » for·(int·i·=·0;·i·<·num;·i++) | 91 | » » for·(int·i·=·0;·i·<·num;·i++) |
| Offset 140, 23 lines modified | Offset 140, 23 lines modified | ||
| 140 | » » » yield·return·null; | 140 | » » » yield·return·null; |
| 141 | » » } | 141 | » » } |
| 142 | » » this.PreparePlayerForZipline(player,·true); | 142 | » » this.PreparePlayerForZipline(player,·true); |
| 143 | » » yield·return·this.CoWalkPlayerToZipline(player,·start.position); | 143 | » » yield·return·this.CoWalkPlayerToZipline(player,·start.position); |
| 144 | » » GameServerUtils.DebugTime("walkToSeconds",·ref·ziplineTime,·Time.time); | 144 | » » GameServerUtils.DebugTime("walkToSeconds",·ref·ziplineTime,·Time.time); |
| 145 | » » HandZiplinePoolable·currentHand·=·this.GetHand(); | 145 | » » HandZiplinePoolable·currentHand·=·this.GetHand(); |
| 146 | » » this.playerIdHands[player.PlayerId]·=·currentHand; | 146 | » » this.playerIdHands[player.PlayerId]·=·currentHand; |
| 147 | » » currentHand.SetPlayerColor(player.CurrentOutfit,·PlayerMaterial.MaskType.None); | 147 | » » currentHand.SetPlayerColor(player.CurrentOutfit,·PlayerMaterial.MaskType.None,·player.cosmetics.GetPhantomRoleAlpha()); |
| 148 | » » this.PlaySound(this.attachSound,·start.position,· | 148 | » » this.PlaySound(this.attachSound,·start.position,·player); |
| 149 | » » yield·return·this.CoAnimatePlayerJumpingOnToZipline(player,·fromTop,·currentHand); | 149 | » » yield·return·this.CoAnimatePlayerJumpingOnToZipline(player,·fromTop,·currentHand); |
| 150 | » » GameServerUtils.DebugTime("jumpToSeconds",·ref·ziplineTime,·Time.time); | 150 | » » GameServerUtils.DebugTime("jumpToSeconds",·ref·ziplineTime,·Time.time); |
| 151 | » » this.StartSound(player,·fromTop); | 151 | » » this.StartSound(player,·fromTop); |
| 152 | » » yield·return·this.CoAnimateZiplineAndPlayer(player,·end.position,·fromTop,·currentHand); | 152 | » » yield·return·this.CoAnimateZiplineAndPlayer(player,·end.position,·fromTop,·currentHand); |
| 153 | » » GameServerUtils.DebugTime("travelSeconds",·ref·ziplineTime,·Time.time); | 153 | » » GameServerUtils.DebugTime("travelSeconds",·ref·ziplineTime,·Time.time); |
| 154 | » » this.StopZiplineSound(player); | 154 | » » this.StopZiplineSound(player); |
| 155 | » » this.PlaySound(this.detachSound,·end.position,· | 155 | » » this.PlaySound(this.detachSound,·end.position,·player); |
| 156 | » » yield·return·this.CoAlightPlayerFromZipline(player,·landing.position,·fromTop,·currentHand); | 156 | » » yield·return·this.CoAlightPlayerFromZipline(player,·landing.position,·fromTop,·currentHand); |
| 157 | » » GameServerUtils.DebugTime("jumpFromSeconds·+·walkFrom·+·wait",·ref·ziplineTime,·Time.time); | 157 | » » GameServerUtils.DebugTime("jumpFromSeconds·+·walkFrom·+·wait",·ref·ziplineTime,·Time.time); |
| 158 | » » GameServerUtils.DebugTime("totalZiplineSeconds·(compare·this·with·server·log·output)",·ref·totalTime,·Time.time); | 158 | » » GameServerUtils.DebugTime("totalZiplineSeconds·(compare·this·with·server·log·output)",·ref·totalTime,·Time.time); |
| 159 | » » if·(this.lastUsedConsole·&&·player.AmOwner) | 159 | » » if·(this.lastUsedConsole·&&·player.AmOwner) |
| 160 | » » { | 160 | » » { |
| 161 | » » » this.lastUsedConsole.SetDestinationCooldown(); | 161 | » » » this.lastUsedConsole.SetDestinationCooldown(); |
| 162 | » » } | 162 | » » } |
| Offset 165, 14 lines modified | Offset 165, 18 lines modified | ||
| 165 | » » this.ResetZipline(); | 165 | » » this.ResetZipline(); |
| 166 | » » yield·break; | 166 | » » yield·break; |
| 167 | » } | 167 | » } |
| 168 | 168 | ||
| 169 | » private·IEnumerator·CoAnimatePlayerJumpingOnToZipline(PlayerControl·player,·bool·fromTop,·HandZiplinePoolable·hand) | 169 | » private·IEnumerator·CoAnimatePlayerJumpingOnToZipline(PlayerControl·player,·bool·fromTop,·HandZiplinePoolable·hand) |
| 170 | » { | 170 | » { |
| 171 | » » hand.gameObject.SetActive(true); | 171 | » » hand.gameObject.SetActive(true); |
| 172 | » » if·(!player.Visible) | ||
| 173 | » » { | ||
| 174 | » » » hand.Hide(); | ||
| 175 | » » } | ||
| 172 | » » AnimationCurve·animationCurve; | 176 | » » AnimationCurve·animationCurve; |
| 173 | » » if·(fromTop) | 177 | » » if·(fromTop) |
| 174 | » » { | 178 | » » { |
| 175 | » » » hand.StartDownAnimation(); | 179 | » » » hand.StartDownAnimation(); |
| 176 | » » » hand.transform.position·=·this.upHandPosition.position; | 180 | » » » hand.transform.position·=·this.upHandPosition.position; |
| 177 | » » » animationCurve·=·this.jumpZiplineCurve; | 181 | » » » animationCurve·=·this.jumpZiplineCurve; |
| 178 | » » } | 182 | » » } |
| Offset 306, 14 lines modified | Offset 310, 18 lines modified | ||
| 306 | » » base.StartCoroutine(this.CoTogglePetVisibility(player,·0f,·true)); | 310 | » » base.StartCoroutine(this.CoTogglePetVisibility(player,·0f,·true)); |
| 307 | » » yield·return·Effects.Wait(0.1f); | 311 | » » yield·return·Effects.Wait(0.1f); |
| 308 | » » yield·break; | 312 | » » yield·break; |
| 309 | » } | 313 | » } |
| 310 | 314 | ||
| 311 | » private·void·StartSound(PlayerControl·player,·bool·fromTop) | 315 | » private·void·StartSound(PlayerControl·player,·bool·fromTop) |
| 312 | » { | 316 | » { |
| 317 | » » if·(!player.Visible) | ||
| 318 | » » { | ||
| 319 | » » » return; | ||
| 320 | » » } | ||
| 313 | » » this.StopZiplineSound(player); | 321 | » » this.StopZiplineSound(player); |
| 314 | » » if·(fromTop) | 322 | » » if·(fromTop) |
| 315 | » » { | 323 | » » { |
| 316 | » » » this.soundLoopCoroutines[player.PlayerId]·=·this.CoDownSound(player); | 324 | » » » this.soundLoopCoroutines[player.PlayerId]·=·this.CoDownSound(player); |
| 317 | » » » base.StartCoroutine(this.soundLoopCoroutines[player.PlayerId]); | 325 | » » » base.StartCoroutine(this.soundLoopCoroutines[player.PlayerId]); |
| 318 | » » » return; | 326 | » » » return; |
| 319 | » » } | 327 | » » } |
| Offset 363, 33 lines modified | Offset 371, 33 lines modified | ||
| 363 | » » » source.volume·=·0f; | 371 | » » » source.volume·=·0f; |
| 364 | » » » return; | 372 | » » » return; |
| 365 | » » } | 373 | » » } |
| 366 | » » source.volume·=·1f; | 374 | » » source.volume·=·1f; |
| 367 | » » Vector2·truePosition·=·PlayerControl.LocalPlayer.GetTruePosition(); | 375 | » » Vector2·truePosition·=·PlayerControl.LocalPlayer.GetTruePosition(); |
| 368 | » » Vector2·closestPointOnLine·=·this.GetClosestPointOnLine(this.handleBottom.position,·this.handleTop.position,·truePosition); | 376 | » » Vector2·closestPointOnLine·=·this.GetClosestPointOnLine(this.handleBottom.position,·this.handleTop.position,·truePosition); |
| 369 | » » float·num·=·Vector2.Distance(truePosition,·closestPointOnLine); | 377 | » » float·num·=·Vector2.Distance(truePosition,·closestPointOnLine); |
| 370 | » » source.volume·=·SoundManager.GetSoundVolume(closestPointOnLine,·truePosition,·2f,·6f); | 378 | » » source.volume·=·SoundManager.GetSoundVolume(closestPointOnLine,·truePosition,·2f,·6f,·0f); |
| 371 | » » if·(num·<·0.25f) | 379 | » » if·(num·<·0.25f) |
| 372 | » » { | 380 | » » { |
| 373 | » » » VibrationManager.Vibrate(0.15f,·0.15f); | 381 | » » » VibrationManager.Vibrate(0.15f,·0.15f); |
| 374 | » » } | 382 | » » } |
| 375 | » } | 383 | » } |
| 376 | 384 | ||
| 377 | » private·bool·ShouldPlaySound() | 385 | » private·bool·ShouldPlaySound() |
| 378 | » { | 386 | » { |
| 379 | » » return·Constants.ShouldPlaySfx(); | 387 | » » return·Constants.ShouldPlaySfx(); |
| 380 | » } | 388 | » } |
| 381 | 389 | ||
| 382 | » private·void·PlaySound(AudioClip·sound,·Vector2·soundPosition,· | 390 | » private·void·PlaySound(AudioClip·sound,·Vector2·soundPosition,·PlayerControl·player) |
| 383 | » { | 391 | » { |
| 384 | » » if·(!this.ShouldPlaySound()) | 392 | » » if·(!this.ShouldPlaySound()·||·!player.Visible) |
| 385 | » » { | 393 | » » { |
| 386 | » » » return; | 394 | » » » return; |
| 387 | » » } | 395 | » » } |
| 388 | » » float·soundVolume·=·SoundManager.GetSoundVolume(soundPosition,· | 396 | » » float·soundVolume·=·SoundManager.GetSoundVolume(soundPosition,·PlayerControl.LocalPlayer.GetTruePosition(),·2f,·6f,·0f); |
| 389 | » » if·(soundVolume·<=·0f) | 397 | » » if·(soundVolume·<=·0f) |
| 390 | » » { | 398 | » » { |
| 391 | » » » return; | 399 | » » » return; |
| 392 | » » } | 400 | » » } |
| 393 | » » SoundManager.Instance.PlaySoundImmediate(sound,·false,·soundVolume,·1f,·null); | 401 | » » SoundManager.Instance.PlaySoundImmediate(sound,·false,·soundVolume,·1f,·null); |
| 394 | » } | 402 | » } |
| 395 | 403 | ||
| Offset 453, 16 lines modified | Offset 461, 16 lines modified | ||
| 453 | 461 | ||
| 454 | » private·const·float·PET_HIDE_SPEED·=·2f; | 462 | » private·const·float·PET_HIDE_SPEED·=·2f; |
| 455 | 463 | ||
| 456 | » private·const·float·TOGGLE_PET_INVISIBLE_SECONDS·=·0.5f; | 464 | » private·const·float·TOGGLE_PET_INVISIBLE_SECONDS·=·0.5f; |
| 457 | 465 | ||
| 458 | » private·const·float·TOGGLE_PET_VISIBLE_SECONDS·=·0f; | 466 | » private·const·float·TOGGLE_PET_VISIBLE_SECONDS·=·0f; |
| 459 | 467 | ||
| 460 | » [SerializeField] | ||
| 461 | » [Header("Positions")] | 468 | » [Header("Positions")] |
| 469 | » [SerializeField] | ||
| 462 | » private·Transform·handleTop; | 470 | » private·Transform·handleTop; |
| 463 | 471 | ||
| 464 | » [SerializeField] | 472 | » [SerializeField] |
| 465 | » private·Transform·handleBottom; | 473 | » private·Transform·handleBottom; |
| 466 | 474 | ||
| 467 | » [SerializeField] | 475 | » [SerializeField] |
| 468 | » private·Transform·landingPositionBottom; | 476 | » private·Transform·landingPositionBottom; |
| Offset 472, 16 lines modified | Offset 480, 16 lines modified | ||
| 472 | 480 | ||
| 473 | » [SerializeField] | 481 | » [SerializeField] |
| 474 | » private·Transform·dropPositionBottom; | 482 | » private·Transform·dropPositionBottom; |
| 475 | 483 | ||
| 476 | » [SerializeField] | 484 | » [SerializeField] |
| 477 | » private·Transform·dropPositionTop; | 485 | » private·Transform·dropPositionTop; |
| 478 | 486 | ||
| 479 | » [SerializeField] | ||
| 480 | » [Header("Travel·time")] | 487 | » [Header("Travel·time")] |
| 488 | » [SerializeField] | ||
| 481 | » private·float·upTravelTime·=·2f; | 489 | » private·float·upTravelTime·=·2f; |
| 482 | 490 | ||
| 483 | » [SerializeField] | 491 | » [SerializeField] |
| Max diff block lines reached; 57/4847 bytes (1.18%) of diff not shown. | |||
| Offset 50, 19 lines modified | Offset 50, 19 lines modified | ||
| 50 | » public·void·SetOutline(bool·on,·bool·mainTarget) | 50 | » public·void·SetOutline(bool·on,·bool·mainTarget) |
| 51 | » { | 51 | » { |
| 52 | » » this.image.material.SetFloat("_Outline",·(float)(on·?·1·:·0)); | 52 | » » this.image.material.SetFloat("_Outline",·(float)(on·?·1·:·0)); |
| 53 | » » this.image.material.SetColor("_OutlineColor",·Color.white); | 53 | » » this.image.material.SetColor("_OutlineColor",·Color.white); |
| 54 | » » this.image.material.SetColor("_AddColor",·mainTarget·?·Color.white·:·Color.clear); | 54 | » » this.image.material.SetColor("_AddColor",·mainTarget·?·Color.white·:·Color.clear); |
| 55 | » } | 55 | » } |
| 56 | 56 | ||
| 57 | » public·float·CanUse( | 57 | » public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse) |
| 58 | » { | 58 | » { |
| 59 | » » float·num·=·float.MaxValue; | 59 | » » float·num·=·float.MaxValue; |
| 60 | » » PlayerControl·@object·=·pc.Object; | 60 | » » PlayerControl·@object·=·pc.Object; |
| 61 | » » couldUse·=·!pc.IsDead·&&·@object.CanMove·&&·!@object.isKilling; | 61 | » » couldUse·=·!pc.IsDead·&&·@object.CanMove·&&·!@object.isKilling·&&·pc.Role.CanUse(this); |
| 62 | » » canUse·=·couldUse; | 62 | » » canUse·=·couldUse; |
| 63 | » » if·(canUse) | 63 | » » if·(canUse) |
| 64 | » » { | 64 | » » { |
| 65 | » » » Vector2·truePosition·=·@object.GetTruePosition(); | 65 | » » » Vector2·truePosition·=·@object.GetTruePosition(); |
| 66 | » » » Vector3·position·=·base.transform.position; | 66 | » » » Vector3·position·=·base.transform.position; |
| 67 | » » » num·=·Vector2.Distance(truePosition,·position); | 67 | » » » num·=·Vector2.Distance(truePosition,·position); |
| 68 | » » » canUse·&=·num·<=·this.UsableDistance·&&·!PhysicsHelpers.AnythingBetween(truePosition,·position,·Constants.ShipOnlyMask,·false); | 68 | » » » canUse·&=·num·<=·this.UsableDistance·&&·!PhysicsHelpers.AnythingBetween(truePosition,·position,·Constants.ShipOnlyMask,·false); |